From f5d52cc9b2284cfc3c78d18d2ea7a5e9a24ee0d1 Mon Sep 17 00:00:00 2001 From: Daniel James Date: Tue, 16 Sep 2008 21:49:41 +0000 Subject: [PATCH] Move the unordered headers into the unordered directory. [SVN r48803] --- include/boost/unordered/unordered_map.hpp | 788 ++++++++++++++++++++++ include/boost/unordered/unordered_set.hpp | 745 ++++++++++++++++++++ include/boost/unordered_map.hpp | 772 +-------------------- include/boost/unordered_set.hpp | 729 +------------------- 4 files changed, 1535 insertions(+), 1499 deletions(-) create mode 100644 include/boost/unordered/unordered_map.hpp create mode 100644 include/boost/unordered/unordered_set.hpp diff --git a/include/boost/unordered/unordered_map.hpp b/include/boost/unordered/unordered_map.hpp new file mode 100644 index 00000000..62647001 --- /dev/null +++ b/include/boost/unordered/unordered_map.hpp @@ -0,0 +1,788 @@ + +// 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 +#include +#include + +#if !defined(BOOST_HAS_RVALUE_REFS) +#include +#endif + +namespace boost +{ + template + class unordered_map + { + typedef boost::unordered_detail::hash_types_unique_keys< + std::pair, Key, Hash, Pred, Alloc + > implementation; + + BOOST_DEDUCED_TYPENAME implementation::hash_table base; + + public: + + // types + + typedef Key key_type; + typedef std::pair 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 + unordered_map(InputIterator f, InputIterator l) + : base(f, l, boost::unordered_detail::default_initial_bucket_count, + hasher(), key_equal(), allocator_type()) + { + } + + template + 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 > 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 + std::pair emplace(Args&&... args) + { + return boost::unordered_detail::pair_cast( + base.insert(std::forward(args)...)); + } + + template + iterator emplace_hint(const_iterator hint, Args&&... args) + { + return iterator(base.insert_hint(get(hint), std::forward(args)...)); + } +#endif + + std::pair insert(const value_type& obj) + { + return boost::unordered_detail::pair_cast( + base.insert(obj)); + } + + iterator insert(const_iterator hint, const value_type& obj) + { + return iterator(base.insert_hint(get(hint), obj)); + } + + template + 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 + equal_range(const key_type& k) + { + return boost::unordered_detail::pair_cast( + base.equal_range(k)); + } + + std::pair + equal_range(const key_type& k) const + { + return boost::unordered_detail::pair_cast( + 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 + inline bool operator==(unordered_map const& m1, + unordered_map const& m2) + { + return boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline bool operator!=(unordered_map const& m1, + unordered_map const& m2) + { + return !boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline void swap(unordered_map &m1, + unordered_map &m2) + { + m1.swap(m2); + } + + template + class unordered_multimap + { + typedef boost::unordered_detail::hash_types_equivalent_keys< + std::pair, Key, Hash, Pred, Alloc + > implementation; + + BOOST_DEDUCED_TYPENAME implementation::hash_table base; + + public: + + // types + + typedef Key key_type; + typedef std::pair 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 + unordered_multimap(InputIterator f, InputIterator l) + : base(f, l, boost::unordered_detail::default_initial_bucket_count, + hasher(), key_equal(), allocator_type()) + { + } + + template + 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 > 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 + iterator emplace(Args&&... args) + { + return iterator(base.insert(std::forward(args)...)); + } + + template + iterator emplace_hint(const_iterator hint, Args&&... args) + { + return iterator(base.insert_hint(get(hint), std::forward(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 + 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 + equal_range(const key_type& k) + { + return boost::unordered_detail::pair_cast( + base.equal_range(k)); + } + + std::pair + equal_range(const key_type& k) const + { + return boost::unordered_detail::pair_cast( + 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 + inline bool operator==(unordered_multimap const& m1, + unordered_multimap const& m2) + { + return boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline bool operator!=(unordered_multimap const& m1, + unordered_multimap const& m2) + { + return !boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline void swap(unordered_multimap &m1, + unordered_multimap &m2) + { + m1.swap(m2); + } + +} // namespace boost + +#endif // BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED diff --git a/include/boost/unordered/unordered_set.hpp b/include/boost/unordered/unordered_set.hpp new file mode 100644 index 00000000..cfb73ad5 --- /dev/null +++ b/include/boost/unordered/unordered_set.hpp @@ -0,0 +1,745 @@ + +// 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 +#include +#include + +#if !defined(BOOST_HAS_RVALUE_REFS) +#include +#endif + +namespace boost +{ + template + 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 + unordered_set(InputIterator f, InputIterator l) + : base(f, l, boost::unordered_detail::default_initial_bucket_count, + hasher(), key_equal(), allocator_type()) + { + } + + template + 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 > 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 + std::pair emplace(Args&&... args) + { + return boost::unordered_detail::pair_cast( + base.insert(std::forward(args)...)); + } + + template + iterator emplace_hint(const_iterator hint, Args&&... args) + { + return iterator( + base.insert_hint(get(hint), std::forward(args)...)); + } +#endif + + std::pair insert(const value_type& obj) + { + return boost::unordered_detail::pair_cast( + base.insert(obj)); + } + + iterator insert(const_iterator hint, const value_type& obj) + { + return iterator(base.insert_hint(get(hint), obj)); + } + + template + 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 + equal_range(const key_type& k) const + { + return boost::unordered_detail::pair_cast( + 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 + inline bool operator==(unordered_set const& m1, + unordered_set const& m2) + { + return boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline bool operator!=(unordered_set const& m1, + unordered_set const& m2) + { + return !boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline void swap(unordered_set &m1, + unordered_set &m2) + { + m1.swap(m2); + } + + template + 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 + unordered_multiset(InputIterator f, InputIterator l) + : base(f, l, boost::unordered_detail::default_initial_bucket_count, + hasher(), key_equal(), allocator_type()) + { + } + + template + 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 > 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 + iterator emplace(Args&&... args) + { + return iterator(base.insert(std::forward(args)...)); + } + + template + iterator emplace_hint(const_iterator hint, Args&&... args) + { + return iterator(base.insert_hint(get(hint), std::forward(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 + 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 + equal_range(const key_type& k) const + { + return boost::unordered_detail::pair_cast( + 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 + inline bool operator==(unordered_multiset const& m1, + unordered_multiset const& m2) + { + return boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline bool operator!=(unordered_multiset const& m1, + unordered_multiset const& m2) + { + return !boost::unordered_detail::equals(m1.base, m2.base); + } + + template + inline void swap(unordered_multiset &m1, + unordered_multiset &m2) + { + m1.swap(m2); + } + +} // namespace boost + +#endif // BOOST_UNORDERED_UNORDERED_SET_HPP_INCLUDED diff --git a/include/boost/unordered_map.hpp b/include/boost/unordered_map.hpp index f4593517..00d3c91c 100644 --- a/include/boost/unordered_map.hpp +++ b/include/boost/unordered_map.hpp @@ -13,776 +13,6 @@ # pragma once #endif -#include -#include -#include - -#if !defined(BOOST_HAS_RVALUE_REFS) -#include -#endif - -namespace boost -{ - template - class unordered_map - { - typedef boost::unordered_detail::hash_types_unique_keys< - std::pair, Key, Hash, Pred, Alloc - > implementation; - - BOOST_DEDUCED_TYPENAME implementation::hash_table base; - - public: - - // types - - typedef Key key_type; - typedef std::pair 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 - unordered_map(InputIterator f, InputIterator l) - : base(f, l, boost::unordered_detail::default_initial_bucket_count, - hasher(), key_equal(), allocator_type()) - { - } - - template - 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 > 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 - std::pair emplace(Args&&... args) - { - return boost::unordered_detail::pair_cast( - base.insert(std::forward(args)...)); - } - - template - iterator emplace_hint(const_iterator hint, Args&&... args) - { - return iterator(base.insert_hint(get(hint), std::forward(args)...)); - } -#endif - - std::pair insert(const value_type& obj) - { - return boost::unordered_detail::pair_cast( - base.insert(obj)); - } - - iterator insert(const_iterator hint, const value_type& obj) - { - return iterator(base.insert_hint(get(hint), obj)); - } - - template - 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 - equal_range(const key_type& k) - { - return boost::unordered_detail::pair_cast( - base.equal_range(k)); - } - - std::pair - equal_range(const key_type& k) const - { - return boost::unordered_detail::pair_cast( - 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 - inline bool operator==(unordered_map const& m1, - unordered_map const& m2) - { - return boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline bool operator!=(unordered_map const& m1, - unordered_map const& m2) - { - return !boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline void swap(unordered_map &m1, - unordered_map &m2) - { - m1.swap(m2); - } - - template - class unordered_multimap - { - typedef boost::unordered_detail::hash_types_equivalent_keys< - std::pair, Key, Hash, Pred, Alloc - > implementation; - - BOOST_DEDUCED_TYPENAME implementation::hash_table base; - - public: - - // types - - typedef Key key_type; - typedef std::pair 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 - unordered_multimap(InputIterator f, InputIterator l) - : base(f, l, boost::unordered_detail::default_initial_bucket_count, - hasher(), key_equal(), allocator_type()) - { - } - - template - 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 > 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 - iterator emplace(Args&&... args) - { - return iterator(base.insert(std::forward(args)...)); - } - - template - iterator emplace_hint(const_iterator hint, Args&&... args) - { - return iterator(base.insert_hint(get(hint), std::forward(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 - 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 - equal_range(const key_type& k) - { - return boost::unordered_detail::pair_cast( - base.equal_range(k)); - } - - std::pair - equal_range(const key_type& k) const - { - return boost::unordered_detail::pair_cast( - 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 - inline bool operator==(unordered_multimap const& m1, - unordered_multimap const& m2) - { - return boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline bool operator!=(unordered_multimap const& m1, - unordered_multimap const& m2) - { - return !boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline void swap(unordered_multimap &m1, - unordered_multimap &m2) - { - m1.swap(m2); - } - -} // namespace boost +#include #endif // BOOST_UNORDERED_MAP_HPP_INCLUDED diff --git a/include/boost/unordered_set.hpp b/include/boost/unordered_set.hpp index 9e4f12b4..98c3ce1d 100644 --- a/include/boost/unordered_set.hpp +++ b/include/boost/unordered_set.hpp @@ -13,733 +13,6 @@ # pragma once #endif -#include -#include -#include - -#if !defined(BOOST_HAS_RVALUE_REFS) -#include -#endif - -namespace boost -{ - template - 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 - unordered_set(InputIterator f, InputIterator l) - : base(f, l, boost::unordered_detail::default_initial_bucket_count, - hasher(), key_equal(), allocator_type()) - { - } - - template - 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 > 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 - std::pair emplace(Args&&... args) - { - return boost::unordered_detail::pair_cast( - base.insert(std::forward(args)...)); - } - - template - iterator emplace_hint(const_iterator hint, Args&&... args) - { - return iterator( - base.insert_hint(get(hint), std::forward(args)...)); - } -#endif - - std::pair insert(const value_type& obj) - { - return boost::unordered_detail::pair_cast( - base.insert(obj)); - } - - iterator insert(const_iterator hint, const value_type& obj) - { - return iterator(base.insert_hint(get(hint), obj)); - } - - template - 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 - equal_range(const key_type& k) const - { - return boost::unordered_detail::pair_cast( - 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 - inline bool operator==(unordered_set const& m1, - unordered_set const& m2) - { - return boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline bool operator!=(unordered_set const& m1, - unordered_set const& m2) - { - return !boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline void swap(unordered_set &m1, - unordered_set &m2) - { - m1.swap(m2); - } - - template - 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 - unordered_multiset(InputIterator f, InputIterator l) - : base(f, l, boost::unordered_detail::default_initial_bucket_count, - hasher(), key_equal(), allocator_type()) - { - } - - template - 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 > 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 - iterator emplace(Args&&... args) - { - return iterator(base.insert(std::forward(args)...)); - } - - template - iterator emplace_hint(const_iterator hint, Args&&... args) - { - return iterator(base.insert_hint(get(hint), std::forward(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 - 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 - equal_range(const key_type& k) const - { - return boost::unordered_detail::pair_cast( - 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 - inline bool operator==(unordered_multiset const& m1, - unordered_multiset const& m2) - { - return boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline bool operator!=(unordered_multiset const& m1, - unordered_multiset const& m2) - { - return !boost::unordered_detail::equals(m1.base, m2.base); - } - - template - inline void swap(unordered_multiset &m1, - unordered_multiset &m2) - { - m1.swap(m2); - } - -} // namespace boost +#include #endif // BOOST_UNORDERED_SET_HPP_INCLUDED