Subject: [Boost-commit] svn:boost r53328 - in branches/release: . boost/unordered boost/unordered/detail libs/unordered/doc libs/unordered/test/helpers libs/unordered/test/unordered
From: daniel_james_at_[hidden]
Date: 2009-05-27 17:31:10
Author: danieljames
Date: 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
New Revision: 53328
URL: http://svn.boost.org/trac/boost/changeset/53328
Log:
Second try at merging emplace support.
Note that the previously rolled back commit was [53257], not [52357].
Merged revisions 52393-52394,52397,52884-52885,53255 via svnmerge from
https://svn.boost.org/svn/boost/trunk
........
r52393 | danieljames | 2009-04-14 18:23:37 +0100 (Tue, 14 Apr 2009) | 2 lines
Implement full extract_key for compilers without SFINAE and variadic
templates.
........
r52394 | danieljames | 2009-04-14 18:23:51 +0100 (Tue, 14 Apr 2009) | 1 line
Use emplace instead of insert in the backend as it's more appropriate.
........
r52397 | danieljames | 2009-04-14 18:51:34 +0100 (Tue, 14 Apr 2009) | 1 line
Add stream output to the count test helper for unordered.
........
r52884 | danieljames | 2009-05-10 22:24:41 +0100 (Sun, 10 May 2009) | 19 lines
Cherrypick some unordered container changes from sandbox. Not including
anything which depends on the new move library.
------------------------------------------------------------------------
r52746 | danieljames | 2009-05-03 11:12:30 +0100 (Sun, 03 May 2009) | 1 line
Merge latest unordered container changes.
------------------------------------------------------------------------
r52747 | danieljames | 2009-05-03 11:15:35 +0100 (Sun, 03 May 2009) | 4 lines
Put the C++0x emplace implementations before the non-C++0x versions.
I'm going to change the non-C++0x to be macro heavy emulations of the
C++0x versions, so this will put the readable version first.
------------------------------------------------------------------------
r52748 | danieljames | 2009-05-03 11:15:44 +0100 (Sun, 03 May 2009) | 1 line
Refactor the unordered implementation a tad, to make implementing emplace less painful.
------------------------------------------------------------------------
........
r52885 | danieljames | 2009-05-10 22:25:09 +0100 (Sun, 10 May 2009) | 1 line
Merge emplace support for sandbox - but without move support.
........
r53255 | danieljames | 2009-05-25 20:45:06 +0100 (Mon, 25 May 2009) | 1 line
Unordered change log.
........
Properties modified:
branches/release/ (props changed)
Text files modified:
branches/release/boost/unordered/detail/hash_table.hpp | 26 +
branches/release/boost/unordered/detail/hash_table_impl.hpp | 579 ++++++++++++++++++++++++++++-----------
branches/release/boost/unordered/unordered_map.hpp | 104 ++++++
branches/release/boost/unordered/unordered_set.hpp | 103 ++++++
branches/release/libs/unordered/doc/changes.qbk | 10
branches/release/libs/unordered/test/helpers/count.hpp | 7
branches/release/libs/unordered/test/unordered/compile_tests.hpp | 8
branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp | 64 ++-
8 files changed, 678 insertions(+), 223 deletions(-)
Modified: branches/release/boost/unordered/detail/hash_table.hpp
==============================================================================
--- branches/release/boost/unordered/detail/hash_table.hpp (original)
+++ branches/release/boost/unordered/detail/hash_table.hpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -13,6 +13,10 @@
#include <boost/config.hpp>
+#if !defined(BOOST_UNORDERED_EMPLACE_LIMIT)
+#define BOOST_UNORDERED_EMPLACE_LIMIT 5
+#endif
+
#include <cstddef>
#include <boost/config/no_tr1/cmath.hpp>
#include <algorithm>
@@ -28,8 +32,12 @@
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/remove_const.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/not.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/utility/swap.hpp>
#include <boost/preprocessor/seq/size.hpp>
@@ -37,11 +45,19 @@
#include <boost/mpl/aux_/config/eti.hpp>
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/not.hpp>
+#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
+
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+
+#define BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ BOOST_PP_ENUM_PARAMS_Z(z, n, typename Arg)
+#define BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, const& arg)
+#define BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ BOOST_PP_ENUM_PARAMS_Z(z, n, arg)
+
#endif
#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0582)
Modified: branches/release/boost/unordered/detail/hash_table_impl.hpp
==============================================================================
--- branches/release/boost/unordered/detail/hash_table_impl.hpp (original)
+++ branches/release/boost/unordered/detail/hash_table_impl.hpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -181,55 +181,158 @@
}
}
+ void construct_preamble()
+ {
+ if(!node_) {
+ node_constructed_ = false;
+ value_constructed_ = false;
+
+ node_ = allocators_.node_alloc_.allocate(1);
+ allocators_.node_alloc_.construct(node_, node());
+ node_constructed_ = true;
+ }
+ else {
+ BOOST_ASSERT(node_constructed_ && value_constructed_);
+ BOOST_UNORDERED_DESTRUCT(&node_->value(), value_type);
+ value_constructed_ = false;
+ }
+ }
+
#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
template <typename... Args>
void construct(Args&&... args)
{
- BOOST_ASSERT(!node_);
- node_constructed_ = false;
- value_constructed_ = false;
-
- node_ = allocators_.node_alloc_.allocate(1);
+ construct_preamble();
+ new(node_->address()) value_type(std::forward<Args>(args)...);
+ value_constructed_ = true;
+ }
- allocators_.node_alloc_.construct(node_, node());
- node_constructed_ = true;
+#if defined(__GLIBCPP__) || defined(__GLIBCXX__)
+ // The GCC C++0x standard library implementation does not have
+ // a single argument pair constructor, so this works around that.
- new(node_->address()) value_type(std::forward<Args>(args)...);
+ template <typename Arg>
+ void construct(Arg&& arg)
+ {
+ construct_preamble();
+ construct_impl(std::forward<Arg>(arg),
+ (value_type const*) 0,
+ (typename boost::remove_reference<Arg>::type const*) 0);
value_constructed_ = true;
}
-#else
- template <typename V>
- void construct(V const& v)
+
+ template <
+ typename Arg,
+ typename ValueType,
+ typename Type>
+ void construct_impl(Arg&& arg, ValueType const*, Type const*)
{
- BOOST_ASSERT(!node_);
- node_constructed_ = false;
- value_constructed_ = false;
+ new(node_->address()) value_type(std::forward<Arg>(arg));
+ }
- node_ = allocators_.node_alloc_.allocate(1);
+ template <
+ typename Arg,
+ typename ValueFirst, typename ValueSecond,
+ typename TypeFirst, typename TypeSecond>
+ void construct_impl(
+ Arg&& arg,
+ std::pair<ValueFirst, ValueSecond> const*,
+ std::pair<TypeFirst, TypeSecond> const*)
+ {
+ new(node_->address()) value_type(std::forward<Arg>(arg));
+ }
- allocators_.node_alloc_.construct(node_, node());
- node_constructed_ = true;
+ template <
+ typename Arg,
+ typename ValueFirst, typename ValueSecond,
+ typename Type>
+ void construct_impl(
+ Arg&& arg,
+ std::pair<ValueFirst, ValueSecond> const*,
+ Type const*)
+ {
+ new(node_->address()) value_type(std::forward<Arg>(arg), ValueSecond());
+ }
+#endif
+
+#else
- new(node_->address()) value_type(v);
+ void construct()
+ {
+ construct_preamble();
+ new(node_->address()) value_type;
value_constructed_ = true;
}
-#endif
- template <typename K, typename M>
- void construct_pair(K const& k, M*)
+#define BOOST_UNORDERED_CONSTRUCT_IMPL(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ void construct( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ construct_preamble(); \
+ construct_impl( \
+ (value_type*) 0, \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ value_constructed_ = true; \
+ } \
+ \
+ template < \
+ typename T, \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ void construct_impl( \
+ T*, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ new(node_->address()) value_type( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ } \
+ \
+
+#define BOOST_UNORDERED_CONSTRUCT_IMPL2(z, n, _) \
+ template <typename First, typename Second, typename Key, \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ void construct_impl( \
+ std::pair<First, Second>*, \
+ Key const& k, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ new(node_->address()) value_type(k, \
+ Second( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ) \
+ ); \
+ }
+
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_CONSTRUCT_IMPL, _)
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_CONSTRUCT_IMPL2, _)
+
+ template <typename First, typename Second, typename T1, typename T2>
+ void construct_impl(std::pair<First, Second>*,
+ std::pair<T1, T2> const& arg0)
{
- BOOST_ASSERT(!node_);
- node_constructed_ = false;
- value_constructed_ = false;
+ new(node_->address()) value_type(arg0);
+ }
- node_ = allocators_.node_alloc_.allocate(1);
+ template <typename First, typename Second, typename Key>
+ void construct_impl(std::pair<First, Second>*, Key const& k)
+ {
+ new(node_->address()) value_type(First(k), Second());
+ }
- allocators_.node_alloc_.construct(node_, node());
- node_constructed_ = true;
+#undef BOOST_UNORDERED_CONSTRUCT_IMPL
- new(node_->address()) value_type(k, M());
- value_constructed_ = true;
- }
+#endif
node_ptr get() const
{
@@ -1427,8 +1530,29 @@
}
// key extractors
-
+ //
// no throw
+ //
+ // 'extract_key' is called with the emplace parameters to return a
+ // key if available or 'no_key' is one isn't and will need to be
+ // constructed.
+
+ struct no_key {
+ no_key() {}
+ template <class T> no_key(T const&) {}
+ };
+
+
+ // If emplace is called with no arguments then there obviously
+ // isn't an available key.
+
+ static no_key extract_key()
+ {
+ return no_key();
+ }
+
+ // Emplace or insert was called with the value type.
+
static key_type const& extract_key(value_type const& v)
{
return extract(v, (type_wrapper<value_type>*)0);
@@ -1445,40 +1569,67 @@
{
return v.first;
}
-
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
- struct no_key {};
-
- template <typename Arg1, typename... Args>
- static typename boost::enable_if<
- boost::mpl::and_<
- boost::mpl::not_<boost::is_same<key_type, value_type> >,
- boost::is_same<Arg1, key_type>
- >,
- key_type>::type const& extract_key(Arg1 const& k, Args const&...)
+
+ // For maps, if emplace is called with just a key, then it's the value type
+ // with the second value default initialised.
+
+ template <typename Arg>
+ static BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_<boost::is_same<Arg, key_type>, key_type const&, no_key>::type
+ extract_key(Arg const& k)
{
return k;
}
+ // For a map, the argument might be a pair with the key as the first
+ // part and a convertible value as the second part.
+
template <typename First, typename Second>
- static typename boost::enable_if<
- boost::mpl::and_<
- boost::mpl::not_<boost::is_same<key_type, value_type> >,
- boost::is_same<key_type,
- typename boost::remove_const<
- typename boost::remove_reference<First>::type
- >::type>
- >,
- key_type>::type const& extract_key(std::pair<First, Second> const& v)
+ static BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_<
+ boost::mpl::and_<
+ boost::mpl::not_<boost::is_same<key_type, value_type> >,
+ boost::is_same<key_type,
+ typename boost::remove_const<
+ typename boost::remove_reference<First>::type
+ >::type>
+ >,
+ key_type const&, no_key
+ >::type extract_key(std::pair<First, Second> const& v)
{
return v.first;
}
- template <typename... Args>
- static no_key extract_key(Args const&...)
+ // For maps if there is more than one argument, the key can be the first argument.
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
+ template <typename Arg, typename Arg1, typename... Args>
+ static BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_<
+ boost::mpl::and_<
+ boost::mpl::not_<boost::is_same<value_type, key_type> >,
+ boost::is_same<Arg, key_type>
+ >,
+ key_type const&, no_key
+ >::type extract_key(Arg const& k, Arg1 const&, Args const&...)
{
- return no_key();
+ return k;
+ }
+
+#else
+ template <typename Arg, typename Arg1>
+ static BOOST_DEDUCED_TYPENAME
+ boost::mpl::if_<
+ boost::mpl::and_<
+ boost::mpl::not_<boost::is_same<value_type, key_type> >,
+ boost::is_same<Arg, key_type>
+ >,
+ key_type const&, no_key
+ >::type extract_key(Arg const& k, Arg1 const&)
+ {
+ return k;
}
+
#endif
public:
@@ -1582,72 +1733,78 @@
#if BOOST_UNORDERED_EQUIVALENT_KEYS
-#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
- // Insert (equivalent key containers)
-
- // if hash function throws, basic exception safety
- // strong otherwise
- iterator_base insert(value_type const& v)
- {
- // Create the node before rehashing in case it throws an
- // exception (need strong safety in such a case).
- node_constructor a(data_.allocators_);
- a.construct(v);
-
- return insert_impl(a);
- }
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
- // Insert (equivalent key containers)
+ // Emplace (equivalent key containers)
+ // (I'm using an overloaded emplace for both 'insert' and 'emplace')
// if hash function throws, basic exception safety
// strong otherwise
- iterator_base insert_hint(iterator_base const& it, value_type const& v)
+ template <class... Args>
+ iterator_base emplace(Args&&... args)
{
// Create the node before rehashing in case it throws an
// exception (need strong safety in such a case).
node_constructor a(data_.allocators_);
- a.construct(v);
+ a.construct(std::forward<Args>(args)...);
- return insert_hint_impl(it, a);
+ return emplace_impl(a);
}
-#else
-
- // Insert (equivalent key containers)
- // (I'm using an overloaded insert for both 'insert' and 'emplace')
+ // Emplace (equivalent key containers)
+ // (I'm using an overloaded emplace for both 'insert' and 'emplace')
// if hash function throws, basic exception safety
// strong otherwise
template <class... Args>
- iterator_base insert(Args&&... args)
+ iterator_base emplace_hint(iterator_base const& it, Args&&... args)
{
// Create the node before rehashing in case it throws an
// exception (need strong safety in such a case).
node_constructor a(data_.allocators_);
a.construct(std::forward<Args>(args)...);
- return insert_impl(a);
+ return emplace_hint_impl(it, a);
}
- // Insert (equivalent key containers)
- // (I'm using an overloaded insert for both 'insert' and 'emplace')
-
- // if hash function throws, basic exception safety
- // strong otherwise
- template <class... Args>
- iterator_base insert_hint(iterator_base const& it, Args&&... args)
- {
- // Create the node before rehashing in case it throws an
- // exception (need strong safety in such a case).
- node_constructor a(data_.allocators_);
- a.construct(std::forward<Args>(args)...);
+#else
- return insert_hint_impl(it, a);
+#define BOOST_UNORDERED_INSERT_IMPL(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator_base emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ node_constructor a(data_.allocators_); \
+ a.construct( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ return emplace_impl(a); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator_base emplace_hint(iterator_base const& it, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ node_constructor a(data_.allocators_); \
+ a.construct( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ return emplace_hint_impl(it, a); \
}
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_INSERT_IMPL, _)
+
+#undef BOOST_UNORDERED_INSERT_IMPL
#endif
- iterator_base insert_impl(node_constructor& a)
+ iterator_base emplace_impl(node_constructor& a)
{
key_type const& k = extract_key(a.get()->value());
size_type hash_value = hash_function()(k);
@@ -1668,17 +1825,17 @@
);
}
- iterator_base insert_hint_impl(iterator_base const& it, node_constructor& a)
+ iterator_base emplace_hint_impl(iterator_base const& it, node_constructor& a)
{
// equal can throw, but with no effects
if (it == data_.end() || !equal(extract_key(a.get()->value()), *it)) {
- // Use the standard insert if the iterator doesn't point
+ // Use the standard emplace if the iterator doesn't point
// to a matching key.
- return insert_impl(a);
+ return emplace_impl(a);
}
else {
// Find the first node in the group - so that the node
- // will be inserted at the end of the group.
+ // will be added at the end of the group.
link_ptr start(it.node_);
while(data_.prev_in_group(start)->next_ == start)
@@ -1707,7 +1864,7 @@
{
size_type distance = unordered_detail::distance(i, j);
if(distance == 1) {
- insert(*i);
+ emplace(*i);
}
else {
// Only require basic exception safety here
@@ -1737,7 +1894,7 @@
{
// If only inserting 1 element, get the required
// safety since insert is only called once.
- for (; i != j; ++i) insert(*i);
+ for (; i != j; ++i) emplace(*i);
}
public:
@@ -1773,7 +1930,7 @@
// Create the node before rehashing in case it throws an
// exception (need strong safety in such a case).
node_constructor a(data_.allocators_);
- a.construct_pair(k, (mapped_type*) 0);
+ a.construct(k);
// reserve has basic exception safety if the hash function
// throws, strong otherwise.
@@ -1786,81 +1943,37 @@
}
}
-#if !(defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL))
-
- // Insert (unique keys)
-
- // if hash function throws, basic exception safety
- // strong otherwise
- std::pair<iterator_base, bool> insert(value_type const& v)
- {
- // No side effects in this initial code
- key_type const& k = extract_key(v);
- size_type hash_value = hash_function()(k);
- bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
- link_ptr pos = find_iterator(bucket, k);
-
- if (BOOST_UNORDERED_BORLAND_BOOL(pos)) {
- // Found an existing key, return it (no throw).
- return std::pair<iterator_base, bool>(
- iterator_base(bucket, pos), false);
-
- } else {
- // Doesn't already exist, add to bucket.
- // Side effects only in this block.
-
- // Create the node before rehashing in case it throws an
- // exception (need strong safety in such a case).
- node_constructor a(data_.allocators_);
- a.construct(v);
-
- // reserve has basic exception safety if the hash function
- // throws, strong otherwise.
- if(reserve_for_insert(size() + 1))
- bucket = data_.bucket_ptr_from_hash(hash_value);
-
- // Nothing after this point can throw.
-
- link_ptr n = data_.link_node_in_bucket(a, bucket);
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
- return std::pair<iterator_base, bool>(
- iterator_base(bucket, n), true);
- }
- }
-
- // Insert (unique keys)
+ // Emplace (unique keys)
+ // (I'm using an overloaded emplace for both 'insert' and 'emplace')
// if hash function throws, basic exception safety
// strong otherwise
- iterator_base insert_hint(iterator_base const& it, value_type const& v)
+ template<typename... Args>
+ std::pair<iterator_base, bool> emplace(Args&&... args)
{
- if(it != data_.end() && equal(extract_key(v), *it))
- return it;
- else
- return insert(v).first;
+ return emplace_impl(
+ extract_key(std::forward<Args>(args)...),
+ std::forward<Args>(args)...);
}
-#else
-
// Insert (unique keys)
- // (I'm using an overloaded insert for both 'insert' and 'emplace')
- //
- // TODO:
- // For sets: create a local key without creating the node?
- // For maps: use the first argument as the key.
+ // (I'm using an overloaded emplace for both 'insert' and 'emplace')
+ // I'm just ignoring hints here for now.
// if hash function throws, basic exception safety
// strong otherwise
template<typename... Args>
- std::pair<iterator_base, bool> insert(Args&&... args)
+ iterator_base emplace_hint(iterator_base const&, Args&&... args)
{
- return insert_impl(
+ return emplace_impl(
extract_key(std::forward<Args>(args)...),
- std::forward<Args>(args)...);
+ std::forward<Args>(args)...).first;
}
template<typename... Args>
- std::pair<iterator_base, bool> insert_impl(key_type const& k, Args&&... args)
+ std::pair<iterator_base, bool> emplace_impl(key_type const& k, Args&&... args)
{
// No side effects in this initial code
size_type hash_value = hash_function()(k);
@@ -1894,13 +2007,110 @@
}
template<typename... Args>
- std::pair<iterator_base, bool> insert_impl(no_key, Args&&... args)
+ std::pair<iterator_base, bool> emplace_impl(no_key, Args&&... args)
{
// Construct the node regardless - in order to get the key.
// It will be discarded if it isn't used
node_constructor a(data_.allocators_);
a.construct(std::forward<Args>(args)...);
+ return emplace_impl_with_node(a);
+ }
+#else
+ template <typename Arg0>
+ std::pair<iterator_base, bool> emplace(Arg0 const& arg0)
+ {
+ return emplace_impl(extract_key(arg0), arg0);
+ }
+
+ template <typename Arg0>
+ iterator_base emplace_hint(iterator_base const& it, Arg0 const& arg0)
+ {
+ return emplace_impl(extract_key(arg0), arg0).first;
+ }
+
+
+#define BOOST_UNORDERED_INSERT_IMPL(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ std::pair<iterator_base, bool> emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return emplace_impl( \
+ extract_key(arg0, arg1), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator_base emplace_hint(iterator_base const& it, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return emplace_impl( \
+ extract_key(arg0, arg1), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ).first; \
+ } \
+ BOOST_UNORDERED_INSERT_IMPL2(z, n, _)
+
+#define BOOST_UNORDERED_INSERT_IMPL2(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ std::pair<iterator_base, bool> emplace_impl(key_type const& k, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ size_type hash_value = hash_function()(k); \
+ bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value); \
+ link_ptr pos = find_iterator(bucket, k); \
+ \
+ if (BOOST_UNORDERED_BORLAND_BOOL(pos)) { \
+ return std::pair<iterator_base, bool>( \
+ iterator_base(bucket, pos), false); \
+ } else { \
+ node_constructor a(data_.allocators_); \
+ a.construct( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ \
+ if(reserve_for_insert(size() + 1)) \
+ bucket = data_.bucket_ptr_from_hash(hash_value); \
+ \
+ return std::pair<iterator_base, bool>(iterator_base(bucket, \
+ data_.link_node_in_bucket(a, bucket)), true); \
+ } \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ std::pair<iterator_base, bool> emplace_impl(no_key, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ node_constructor a(data_.allocators_); \
+ a.construct( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ ); \
+ return emplace_impl_with_node(a); \
+ }
+ BOOST_UNORDERED_INSERT_IMPL2(1, 1, _)
+
+ BOOST_PP_REPEAT_FROM_TO(2, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_INSERT_IMPL, _)
+
+#undef BOOST_UNORDERED_INSERT_IMPL
+
+#endif
+
+ std::pair<iterator_base, bool> emplace_impl_with_node(node_constructor& a)
+ {
// No side effects in this initial code
key_type const& k = extract_key(a.get()->value());
size_type hash_value = hash_function()(k);
@@ -1924,19 +2134,6 @@
}
}
- // Insert (unique keys)
- // (I'm using an overloaded insert for both 'insert' and 'emplace')
-
- // if hash function throws, basic exception safety
- // strong otherwise
- template<typename... Args>
- iterator_base insert_hint(iterator_base const&, Args&&... args)
- {
- // Life is complicated - just call the normal implementation.
- return insert(std::forward<Args>(args)...).first;
- }
-#endif
-
// Insert from iterators (unique keys)
template <typename I>
@@ -1964,6 +2161,13 @@
template <typename InputIterator>
void insert_range(InputIterator i, InputIterator j)
{
+ if(i != j)
+ return insert_range_impl(extract_key(*i), i, j);
+ }
+
+ template <typename InputIterator>
+ void insert_range_impl(key_type const&, InputIterator i, InputIterator j)
+ {
node_constructor a(data_.allocators_);
for (; i != j; ++i) {
@@ -1992,6 +2196,36 @@
}
}
}
+
+ template <typename InputIterator>
+ void insert_range_impl(no_key, InputIterator i, InputIterator j)
+ {
+ node_constructor a(data_.allocators_);
+
+ for (; i != j; ++i) {
+ // No side effects in this initial code
+ a.construct(*i);
+ key_type const& k = extract_key(a.get()->value());
+ size_type hash_value = hash_function()(extract_key(k));
+ bucket_ptr bucket = data_.bucket_ptr_from_hash(hash_value);
+ link_ptr pos = find_iterator(bucket, k);
+
+ if (!BOOST_UNORDERED_BORLAND_BOOL(pos)) {
+ // Doesn't already exist, add to bucket.
+ // Side effects only in this block.
+
+ // reserve has basic exception safety if the hash function
+ // throws, strong otherwise.
+ if(size() + 1 >= max_load_) {
+ reserve_for_insert(size() + insert_size(i, j));
+ bucket = data_.bucket_ptr_from_hash(hash_value);
+ }
+
+ // Nothing after this point can throw.
+ data_.link_node_in_bucket(a, bucket);
+ }
+ }
+ }
#endif
public:
@@ -2078,8 +2312,9 @@
key_type const& k) const
{
link_ptr it = data_.begin(bucket);
- while (BOOST_UNORDERED_BORLAND_BOOL(it) && !equal(k, data::get_value(it)))
+ while (BOOST_UNORDERED_BORLAND_BOOL(it) && !equal(k, data::get_value(it))) {
it = data::next_group(it);
+ }
return it;
}
Modified: branches/release/boost/unordered/unordered_map.hpp
==============================================================================
--- branches/release/boost/unordered/unordered_map.hpp (original)
+++ branches/release/boost/unordered/unordered_map.hpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -224,25 +224,69 @@
std::pair<iterator, bool> emplace(Args&&... args)
{
return boost::unordered_detail::pair_cast<iterator, bool>(
- base.insert(std::forward<Args>(args)...));
+ base.emplace(std::forward<Args>(args)...));
}
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
{
- return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
}
+#else
+
+ std::pair<iterator, bool> emplace(value_type const& v = value_type())
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.emplace(v));
+ }
+
+ iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
+ {
+ return iterator(base.emplace_hint(get(hint), v));
+ }
+
+#define BOOST_UNORDERED_EMPLACE(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ std::pair<iterator, bool> emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return boost::unordered_detail::pair_cast<iterator, bool>( \
+ base.emplace( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace_hint(const_iterator hint, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator(base.emplace_hint(get(hint), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ }
+
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_EMPLACE, _)
+
+#undef BOOST_UNORDERED_EMPLACE
+
#endif
std::pair<iterator, bool> insert(const value_type& obj)
{
return boost::unordered_detail::pair_cast<iterator, bool>(
- base.insert(obj));
+ base.emplace(obj));
}
iterator insert(const_iterator hint, const value_type& obj)
{
- return iterator(base.insert_hint(get(hint), obj));
+ return iterator(base.emplace_hint(get(hint), obj));
}
template <class InputIterator>
@@ -630,24 +674,68 @@
template <class... Args>
iterator emplace(Args&&... args)
{
- return iterator(base.insert(std::forward<Args>(args)...));
+ return iterator(base.emplace(std::forward<Args>(args)...));
}
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
{
- return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
}
+#else
+
+ iterator emplace(value_type const& v = value_type())
+ {
+ return iterator(base.emplace(v));
+ }
+
+ iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
+ {
+ return iterator(base.emplace_hint(get(hint), v));
+ }
+
+
+#define BOOST_UNORDERED_EMPLACE(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator( \
+ base.emplace( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace_hint(const_iterator hint, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator(base.emplace_hint(get(hint), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ }
+
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_EMPLACE, _)
+
+#undef BOOST_UNORDERED_EMPLACE
+
#endif
iterator insert(const value_type& obj)
{
- return iterator(base.insert(obj));
+ return iterator(base.emplace(obj));
}
iterator insert(const_iterator hint, const value_type& obj)
{
- return iterator(base.insert_hint(get(hint), obj));
+ return iterator(base.emplace_hint(get(hint), obj));
}
template <class InputIterator>
Modified: branches/release/boost/unordered/unordered_set.hpp
==============================================================================
--- branches/release/boost/unordered/unordered_set.hpp (original)
+++ branches/release/boost/unordered/unordered_set.hpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -222,26 +222,70 @@
std::pair<iterator, bool> emplace(Args&&... args)
{
return boost::unordered_detail::pair_cast<iterator, bool>(
- base.insert(std::forward<Args>(args)...));
+ base.emplace(std::forward<Args>(args)...));
}
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
{
return iterator(
- base.insert_hint(get(hint), std::forward<Args>(args)...));
+ base.emplace_hint(get(hint), std::forward<Args>(args)...));
}
+#else
+
+ std::pair<iterator, bool> emplace(value_type const& v = value_type())
+ {
+ return boost::unordered_detail::pair_cast<iterator, bool>(
+ base.emplace(v));
+ }
+
+ iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
+ {
+ return iterator(base.emplace_hint(get(hint), v));
+ }
+
+#define BOOST_UNORDERED_EMPLACE(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ std::pair<iterator, bool> emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return boost::unordered_detail::pair_cast<iterator, bool>( \
+ base.emplace( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace_hint(const_iterator hint, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator(base.emplace_hint(get(hint), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ }
+
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_EMPLACE, _)
+
+#undef BOOST_UNORDERED_EMPLACE
+
#endif
std::pair<iterator, bool> insert(const value_type& obj)
{
return boost::unordered_detail::pair_cast<iterator, bool>(
- base.insert(obj));
+ base.emplace(obj));
}
iterator insert(const_iterator hint, const value_type& obj)
{
- return iterator(base.insert_hint(get(hint), obj));
+ return iterator(base.emplace_hint(get(hint), obj));
}
template <class InputIterator>
@@ -599,24 +643,67 @@
template <class... Args>
iterator emplace(Args&&... args)
{
- return iterator(base.insert(std::forward<Args>(args)...));
+ return iterator(base.emplace(std::forward<Args>(args)...));
}
template <class... Args>
iterator emplace_hint(const_iterator hint, Args&&... args)
{
- return iterator(base.insert_hint(get(hint), std::forward<Args>(args)...));
+ return iterator(base.emplace_hint(get(hint), std::forward<Args>(args)...));
}
+#else
+
+ iterator emplace(value_type const& v = value_type())
+ {
+ return iterator(base.emplace(v));
+ }
+
+ iterator emplace_hint(const_iterator hint, value_type const& v = value_type())
+ {
+ return iterator(base.emplace_hint(get(hint), v));
+ }
+
+#define BOOST_UNORDERED_EMPLACE(z, n, _) \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace( \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator( \
+ base.emplace( \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ } \
+ \
+ template < \
+ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
+ > \
+ iterator emplace_hint(const_iterator hint, \
+ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
+ ) \
+ { \
+ return iterator(base.emplace_hint(get(hint), \
+ BOOST_UNORDERED_CALL_PARAMS(z, n) \
+ )); \
+ }
+
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_UNORDERED_EMPLACE_LIMIT,
+ BOOST_UNORDERED_EMPLACE, _)
+
+#undef BOOST_UNORDERED_EMPLACE
+
#endif
iterator insert(const value_type& obj)
{
- return iterator(base.insert(obj));
+ return iterator(base.emplace(obj));
}
iterator insert(const_iterator hint, const value_type& obj)
{
- return iterator(base.insert_hint(get(hint), obj));
+ return iterator(base.emplace_hint(get(hint), obj));
}
template <class InputIterator>
Modified: branches/release/libs/unordered/doc/changes.qbk
==============================================================================
--- branches/release/libs/unordered/doc/changes.qbk (original)
+++ branches/release/libs/unordered/doc/changes.qbk 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -69,5 +69,15 @@
* Some other minor internal changes to the implementation, tests and
documentation.
* Avoid an unnecessary copy in `operator[]`.
+* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]: Fix length of
+ prime number list.
+
+[h2 Boost 1.40.0]
+
+* [@https://svn.boost.org/trac/boost/ticket/2975 Ticket 2975]:
+ Store the prime list as a preprocessor sequence - so that it will always get
+ the length right if it changes again in the future.
+* [@https://svn.boost.org/trac/boost/ticket/1978 Ticket 1978]:
+ Implement `emplace` for all compilers.
[endsect]
Modified: branches/release/libs/unordered/test/helpers/count.hpp
==============================================================================
--- branches/release/libs/unordered/test/helpers/count.hpp (original)
+++ branches/release/libs/unordered/test/helpers/count.hpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -6,6 +6,8 @@
#if !defined(BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD)
#define BOOST_UNORDERED_TEST_HELPERS_COUNT_HEAD
+#include <iostream>
+
namespace test {
struct object_count {
int instances;
@@ -36,6 +38,11 @@
bool operator!=(object_count const& x) const {
return !(*this == x);
}
+
+ friend std::ostream& operator<<(std::ostream& out, object_count const& c) {
+ out<<"[instances: "<<c.instances<<", constructions: "<<c.constructions<<"]";
+ return out;
+ }
};
template <class T>
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 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -151,14 +151,12 @@
r.insert(std::pair<Key const, T>(k, v));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
Key k_lvalue(k);
T v_lvalue(v);
r.emplace(k, v);
r.emplace(k_lvalue, v_lvalue);
r.emplace(rvalue(k), rvalue(v));
-#endif
}
template <class X>
@@ -175,9 +173,7 @@
{
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
test::check_return_type<std::pair<iterator, bool> >::equals(r.insert(t));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
test::check_return_type<std::pair<iterator, bool> >::equals(r.emplace(t));
-#endif
}
template <class X, class T>
@@ -185,9 +181,7 @@
{
typedef BOOST_DEDUCED_TYPENAME X::iterator iterator;
test::check_return_type<iterator>::equals(r.insert(t));
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
test::check_return_type<iterator>::equals(r.emplace(t));
-#endif
}
template <class X, class Key, class T>
@@ -289,9 +283,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_hint(q, t));
-#endif
a.insert(i, j);
test::check_return_type<size_type>::equals(a.erase(k));
Modified: branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp
==============================================================================
--- branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp (original)
+++ branches/release/libs/unordered/test/unordered/unnecessary_copy_tests.cpp 2009-05-27 17:31:08 EDT (Wed, 27 May 2009)
@@ -68,12 +68,22 @@
#define COPY_COUNT(n) \
if(count_copies::copies != n) { \
BOOST_ERROR("Wrong number of copies."); \
- std::cerr<<"Number of copies: "<<count_copies::copies<<std::endl; \
+ std::cerr<<"Number of copies: "<<count_copies::copies<<" expecting: "<<n<<std::endl; \
}
#define MOVE_COUNT(n) \
if(count_copies::moves != n) { \
BOOST_ERROR("Wrong number of moves."); \
- std::cerr<<"Number of moves: "<<count_copies::moves<<std::endl; \
+ std::cerr<<"Number of moves: "<<count_copies::moves<<" expecting: "<<n<<std::endl; \
+ }
+#define COPY_COUNT_RANGE(a, b) \
+ if(count_copies::copies < a || count_copies::copies > b) { \
+ BOOST_ERROR("Wrong number of copies."); \
+ std::cerr<<"Number of copies: "<<count_copies::copies<<" expecting: ["<<a<<", "<<b<<"]"<<std::endl; \
+ }
+#define MOVE_COUNT_RANGE(a, b) \
+ if(count_copies::moves < a || count_copies::moves > b) { \
+ BOOST_ERROR("Wrong number of moves."); \
+ std::cerr<<"Number of moves: "<<count_copies::copies<<" expecting: ["<<a<<", "<<b<<"]"<<std::endl; \
}
namespace unnecessary_copy_tests
@@ -99,7 +109,6 @@
UNORDERED_TEST(unnecessary_copy_insert_test,
((set)(multiset)(map)(multimap)))
-#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
template <class T>
void unnecessary_copy_emplace_test(T*)
{
@@ -117,9 +126,19 @@
reset();
T x;
x.emplace(source<BOOST_DEDUCED_TYPENAME T::value_type>());
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
COPY_COUNT(1);
+#else
+ COPY_COUNT(2);
+#endif
}
+ UNORDERED_TEST(unnecessary_copy_emplace_test,
+ ((set)(multiset)(map)(multimap)))
+ UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
+ ((set)(multiset)(map)(multimap)))
+
+#if defined(BOOST_HAS_RVALUE_REFS) && defined(BOOST_HAS_VARIADIC_TMPL)
template <class T>
void unnecessary_copy_emplace_move_test(T*)
{
@@ -131,13 +150,11 @@
COPY_COUNT(1); MOVE_COUNT(1);
}
- UNORDERED_TEST(unnecessary_copy_emplace_test,
- ((set)(multiset)(map)(multimap)))
- UNORDERED_TEST(unnecessary_copy_emplace_rvalue_test,
- ((set)(multiset)(map)(multimap)))
UNORDERED_TEST(unnecessary_copy_emplace_move_test,
((set)(multiset)(map)(multimap)))
+#endif
+
UNORDERED_AUTO_TEST(unnecessary_copy_emplace_set_test)
{
reset();
@@ -172,10 +189,12 @@
x.emplace(source<count_copies>());
COPY_COUNT(1); MOVE_COUNT(0);
+#if defined(BOOST_HAS_RVALUE_REFS)
// No move should take place.
reset();
x.emplace(std::move(a));
COPY_COUNT(0); MOVE_COUNT(0);
+#endif
// Just in case a did get moved...
count_copies b;
@@ -192,8 +211,12 @@
// The container will have to create b copy in order to compare with
// the existing element.
+ //
+ // Note to self: If copy_count == 0 it's an error not an optimization.
+ // TODO: Devise a better test.
reset();
+
x.emplace(b, b);
COPY_COUNT(1); MOVE_COUNT(0);
}
@@ -230,24 +253,22 @@
x.emplace(source<std::pair<count_copies, count_copies> >());
COPY_COUNT(2); MOVE_COUNT(0);
- count_copies part;
- reset();
- std::pair<count_copies const&, count_copies const&> a_ref(part, part);
- x.emplace(a_ref);
- COPY_COUNT(0); MOVE_COUNT(0);
+ // TODO: This doesn't work on older versions of gcc.
+ //count_copies part;
+ std::pair<count_copies const, count_copies> b;
+ //reset();
+ //std::pair<count_copies const&, count_copies const&> a_ref(part, part);
+ //x.emplace(a_ref);
+ //COPY_COUNT(0); MOVE_COUNT(0);
+#if defined(BOOST_HAS_RVALUE_REFS)
// No move should take place.
+ // (since a is already in the container)
reset();
x.emplace(std::move(a));
COPY_COUNT(0); MOVE_COUNT(0);
+#endif
- // Just in case a did get moved
- std::pair<count_copies const, count_copies> b;
-
- // This test requires a C++0x std::pair. Which gcc hasn't got yet.
- //reset();
- //x.emplace(b.first.tag_);
- //COPY_COUNT(2); MOVE_COUNT(0);
//
// 2 arguments
@@ -267,10 +288,9 @@
COPY_COUNT(1); MOVE_COUNT(0);
reset();
- x.emplace(b.first.tag_, b.second.tag_);
- COPY_COUNT(2); MOVE_COUNT(0);
+ x.emplace(count_copies(b.first.tag_), count_copies(b.second.tag_));
+ COPY_COUNT(2); MOVE_COUNT(0);
}
-#endif
}
RUN_TESTS()