From 8591c1f180e5ff07a2a95e5aafa07902138cd48e Mon Sep 17 00:00:00 2001 From: Daniel James Date: Wed, 12 Oct 2011 22:30:02 +0000 Subject: [PATCH] Unordered: merge from trunk. [SVN r74932] --- doc/comparison.qbk | 9 +-- .../unordered/detail/allocator_helpers.hpp | 5 +- .../boost/unordered/detail/emplace_args.hpp | 16 ++--- test/unordered/move_tests.cpp | 69 +++++++++++++++++++ 4 files changed, 83 insertions(+), 16 deletions(-) diff --git a/doc/comparison.qbk b/doc/comparison.qbk index 0924fe5c..30deac11 100644 --- a/doc/comparison.qbk +++ b/doc/comparison.qbk @@ -1,4 +1,4 @@ -[/ Copyright 2006-2008 Daniel James. +[/ Copyright 2006-2011 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) ] @@ -66,15 +66,12 @@ [ [No equivalent] [Local iterators can be used to iterate through individual buckets. - (I don't think that the order of local iterators and iterators are + (The order of local iterators and iterators aren't required to have any correspondence.)] ] [ [Can be compared using the `==`, `!=`, `<`, `<=`, `>`, `>=` operators.] - [No comparison operators are defined in the standard, although - [link unordered.rationale.equality_operators - implementations might extend the containers to support `==` and - `!=`].] + [Can be compared using the `==` and `!=` operators.] ] [ [] diff --git a/include/boost/unordered/detail/allocator_helpers.hpp b/include/boost/unordered/detail/allocator_helpers.hpp index 7a44a479..216eeaef 100644 --- a/include/boost/unordered/detail/allocator_helpers.hpp +++ b/include/boost/unordered/detail/allocator_helpers.hpp @@ -104,7 +104,8 @@ namespace boost { namespace unordered { namespace detail { yes_type is_private_type(private_type const&); struct convert_from_anything { - convert_from_anything(...); + template + convert_from_anything(T const&); }; #if !defined(BOOST_NO_SFINAE_EXPR) || BOOST_WORKAROUND(BOOST_MSVC, >= 1500) @@ -339,7 +340,7 @@ namespace boost { namespace unordered { namespace detail { boost::unordered::detail::has_max_size::value, SizeType >::type call_max_size(const Alloc&) { - return std::numeric_limits::max(); + return (std::numeric_limits::max)(); } template diff --git a/include/boost/unordered/detail/emplace_args.hpp b/include/boost/unordered/detail/emplace_args.hpp index cb56eac2..a4365c21 100644 --- a/include/boost/unordered/detail/emplace_args.hpp +++ b/include/boost/unordered/detail/emplace_args.hpp @@ -223,29 +223,29 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1) #if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT) template struct emulation1 { - static choice1::type check(choice1, std::pair const&); - static choice2::type check(choice2, A const&); - static choice3::type check(choice3, ...); + static choice1::type test(choice1, std::pair const&); + static choice2::type test(choice2, A const&); + static choice3::type test(choice3, convert_from_anything const&); enum { value = - sizeof(check(choose(), boost::unordered::detail::make())) == + sizeof(test(choose(), boost::unordered::detail::make())) == sizeof(choice2::type) }; }; #endif template struct check3_base { - static choice1::type check(choice1, + static choice1::type test(choice1, boost::unordered::piecewise_construct_t); #if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT) - static choice2::type check(choice2, A const&); + static choice2::type test(choice2, A const&); #endif - static choice3::type check(choice3, ...); + static choice3::type test(choice3, ...); enum { value = - sizeof(check(choose(), boost::unordered::detail::make())) }; + sizeof(test(choose(), boost::unordered::detail::make())) }; }; template diff --git a/test/unordered/move_tests.cpp b/test/unordered/move_tests.cpp index 09f3edff..4ecbc6e4 100644 --- a/test/unordered/move_tests.cpp +++ b/test/unordered/move_tests.cpp @@ -193,12 +193,15 @@ namespace move_tests test::check_container(y, v2); test::check_equivalent_keys(y); BOOST_TEST(y.max_load_factor() == 2.0); + +#if defined(BOOST_HAS_NRVO) if (allocator_type::is_propagate_on_move) { BOOST_TEST(test::equivalent(y.get_allocator(), al2)); } else { BOOST_TEST(test::equivalent(y.get_allocator(), al1)); } +#endif } { @@ -214,6 +217,72 @@ namespace move_tests test::check_container(y, v); test::check_equivalent_keys(y); BOOST_TEST(y.max_load_factor() == 0.5); + +#if defined(BOOST_HAS_NRVO) + if (allocator_type::is_propagate_on_move) { + BOOST_TEST(test::equivalent(y.get_allocator(), al2)); + } + else { + BOOST_TEST(test::equivalent(y.get_allocator(), al1)); + } +#endif + } + + { + test::check_instances check_; + + test::random_values v(500, generator); + T y(0, hf, eq, al1); + + T x(0, hf, eq, al2); + x.max_load_factor(0.25); + x.insert(v.begin(), v.end()); + + test::object_count count = test::global_object_count; + y = boost::move(x); + if (allocator_type::is_propagate_on_move) { + BOOST_TEST(count == test::global_object_count); + } + test::check_container(y, v); + test::check_equivalent_keys(y); + BOOST_TEST(y.max_load_factor() == 0.25); + + if (allocator_type::is_propagate_on_move) { + BOOST_TEST(test::equivalent(y.get_allocator(), al2)); + } + else { + BOOST_TEST(test::equivalent(y.get_allocator(), al1)); + } + } + + { + test::check_instances check_; + + test::random_values v1(1000, generator); + test::random_values v2(200, generator); + + T x(0, hf, eq, al2); + x.max_load_factor(0.5); + x.insert(v2.begin(), v2.end()); + + test::object_count count1 = test::global_object_count; + + T y(v1.begin(), v1.end(), 0, hf, eq, al1); + y = boost::move(x); + + test::object_count count2 = test::global_object_count; + + if (allocator_type::is_propagate_on_move) { + BOOST_TEST(count1.instances == + test::global_object_count.instances); + BOOST_TEST(count2.constructions == + test::global_object_count.constructions); + } + + test::check_container(y, v2); + test::check_equivalent_keys(y); + BOOST_TEST(y.max_load_factor() == 0.5); + if (allocator_type::is_propagate_on_move) { BOOST_TEST(test::equivalent(y.get_allocator(), al2)); }