Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r48854 - in branches/release: . boost boost/unordered libs/unordered/doc libs/unordered/test/objects libs/unordered/test/unordered
From: daniel_james_at_[hidden]
Date: 2008-09-18 07:31:00

Next message: dgregor_at_[hidden]: "[Boost-commit] svn:boost r48855 - sandbox/committee/concepts/stdlib"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r48853 - trunk/libs/unordered/doc"

Author: danieljames
Date: 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
New Revision: 48854
URL: http://svn.boost.org/trac/boost/changeset/48854

Log:
Merged revisions 48081-48082,48791,48802-48803,48853 via svnmerge from
https://svn.boost.org/svn/boost/trunk

Added:
   branches/release/boost/unordered/unordered_map.hpp
      - copied unchanged from r48803, /trunk/boost/unordered/unordered_map.hpp
   branches/release/boost/unordered/unordered_map_fwd.hpp
      - copied unchanged from r48803, /trunk/boost/unordered/unordered_map_fwd.hpp
   branches/release/boost/unordered/unordered_set.hpp
      - copied unchanged from r48803, /trunk/boost/unordered/unordered_set.hpp
   branches/release/boost/unordered/unordered_set_fwd.hpp
      - copied unchanged from r48803, /trunk/boost/unordered/unordered_set_fwd.hpp
   branches/release/libs/unordered/test/unordered/fwd_map_test.cpp
      - copied unchanged from r48803, /trunk/libs/unordered/test/unordered/fwd_map_test.cpp
   branches/release/libs/unordered/test/unordered/fwd_set_test.cpp
      - copied unchanged from r48803, /trunk/libs/unordered/test/unordered/fwd_set_test.cpp
Properties modified:
   branches/release/ (props changed)
Text files modified:
   branches/release/boost/unordered_map.hpp | 808 ---------------------------------------
   branches/release/boost/unordered_set.hpp | 763 -------------------------------------
   branches/release/libs/unordered/doc/changes.qbk | 9
   branches/release/libs/unordered/doc/intro.qbk | 2
   branches/release/libs/unordered/doc/ref.xml | 16
   branches/release/libs/unordered/test/objects/minimal.hpp | 2
   branches/release/libs/unordered/test/unordered/Jamfile.v2 | 2
   branches/release/libs/unordered/test/unordered/compile_tests.hpp | 2
   8 files changed, 24 insertions(+), 1580 deletions(-)

Modified: branches/release/boost/unordered_map.hpp
==============================================================================
--- branches/release/boost/unordered_map.hpp (original)
+++ branches/release/boost/unordered_map.hpp 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -13,812 +13,6 @@
# pragma once
#endif

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

#endif // BOOST_UNORDERED_MAP_HPP_INCLUDED

Modified: branches/release/boost/unordered_set.hpp
==============================================================================
--- branches/release/boost/unordered_set.hpp (original)
+++ branches/release/boost/unordered_set.hpp 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -13,767 +13,6 @@
# pragma once
#endif

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

#endif // BOOST_UNORDERED_SET_HPP_INCLUDED

Modified: branches/release/libs/unordered/doc/changes.qbk
==============================================================================
--- branches/release/libs/unordered/doc/changes.qbk (original)
+++ branches/release/libs/unordered/doc/changes.qbk 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -33,4 +33,13 @@
are available.
* Added equality operators.

+[h2 Boost 1.37.0]
+
+* Rename overload of `emplace` with hint, to `emplace_hint` as specified in
+ [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf n2691].
+* Provide forwarding headers at `<boost/unordered/unordered_map_fwd.hpp>` and
+ `<boost/unordered/unordered_set_fwd.hpp>`.
+* Move all the implementation inside `boost/unordered`, to assist
+ modularization and hopefully make it easier to track changes in subversion.
+
[endsect]

Modified: branches/release/libs/unordered/doc/intro.qbk
==============================================================================
--- branches/release/libs/unordered/doc/intro.qbk (original)
+++ branches/release/libs/unordered/doc/intro.qbk 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -9,7 +9,7 @@
     [@http://www.boost.org/doc/html/boost_tr1.html
     Boost.TR1]]
[def __draft__
- [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2007/n2461.pdf
+ [@http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2008/n2691.pdf
     Working Draft of the C++ Standard]]
[def __hash-table__ [@http://en.wikipedia.org/wiki/Hash_table
     hash table]]

Modified: branches/release/libs/unordered/doc/ref.xml
==============================================================================
--- branches/release/libs/unordered/doc/ref.xml (original)
+++ branches/release/libs/unordered/doc/ref.xml 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -24,7 +24,7 @@
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
- <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+ <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -287,7 +287,7 @@
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
- <method name="emplace">
+ <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -754,7 +754,7 @@
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
- <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+ <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -1016,7 +1016,7 @@
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
- <method name="emplace">
+ <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -1488,7 +1488,7 @@
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
- <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+ <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -1757,7 +1757,7 @@
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
- <method name="emplace">
+ <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>
@@ -2267,7 +2267,7 @@
           </purpose>
           <description>
             <para>For the normative reference see chapter 23 of
- <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2461.pdf">the working draft of the C++ standard [n2461].</ulink></para>
+ <ulink url="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2691.pdf">the working draft of the C++ standard [n2691].</ulink></para>
             <para><emphasis role="bold">Template Parameters</emphasis>
               <informaltable>
                 <tgroup cols="2">
@@ -2535,7 +2535,7 @@
                 <para>Only available on compilers with support for variadic template arguments and rvalue references.</para>
               </notes>
             </method>
- <method name="emplace">
+ <method name="emplace_hint">
               <template>
                 <template-type-parameter name="Args" pack="1">
                 </template-type-parameter>

Modified: branches/release/libs/unordered/test/objects/minimal.hpp
==============================================================================
--- branches/release/libs/unordered/test/objects/minimal.hpp (original)
+++ branches/release/libs/unordered/test/objects/minimal.hpp 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -240,7 +240,7 @@
         size_type max_size() const { return 1000; }

#if defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP) || \
- BOOST_WORKAROUND(MSVC, <= 1300)
+ BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
     public: allocator& operator=(allocator const&) { return *this;}
#else
     private: allocator& operator=(allocator const&);

Modified: branches/release/libs/unordered/test/unordered/Jamfile.v2
==============================================================================
--- branches/release/libs/unordered/test/unordered/Jamfile.v2 (original)
+++ branches/release/libs/unordered/test/unordered/Jamfile.v2 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -14,6 +14,8 @@

test-suite unordered
     :
+ [ run fwd_set_test.cpp ]
+ [ run fwd_map_test.cpp ]
         [ run compile_set.cpp ]
         [ run compile_map.cpp ]
         [ run link_test_1.cpp link_test_2.cpp ]

Modified: branches/release/libs/unordered/test/unordered/compile_tests.hpp
==============================================================================
--- branches/release/libs/unordered/test/unordered/compile_tests.hpp (original)
+++ branches/release/libs/unordered/test/unordered/compile_tests.hpp 2008-09-18 07:30:59 EDT (Thu, 18 Sep 2008)
@@ -290,7 +290,7 @@
     const_iterator q = a.cbegin();
     test::check_return_type<iterator>::equals(a.insert(q, t));
#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
- test::check_return_type<iterator>::equals(a.emplace(q, t));
+ test::check_return_type<iterator>::equals(a.emplace_hint(q, t));
#endif

     a.insert(i, j);

Next message: dgregor_at_[hidden]: "[Boost-commit] svn:boost r48855 - sandbox/committee/concepts/stdlib"
Previous message: daniel_james_at_[hidden]: "[Boost-commit] svn:boost r48853 - trunk/libs/unordered/doc"

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk