|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r79868 - in branches/release: . boost boost/unordered boost/unordered/detail libs libs/unordered libs/unordered/test/objects libs/unordered/test/unordered
From: dnljms_at_[hidden]
Date: 2012-08-05 04:34:48
Author: danieljames
Date: 2012-08-05 04:34:44 EDT (Sun, 05 Aug 2012)
New Revision: 79868
URL: http://svn.boost.org/trac/boost/changeset/79868
Log:
Unordered: Merge from trunk
- Avoid an incorrect MSVC unused variable warning in the tests.
- Remove a `try..catch`.
- Adjust SFINAE use to try to supprt g++ 3.4. Fixes #7175.
- Fix some use of rvalues.
- Extra info in `at_tests`.
Properties modified:
branches/release/ (props changed)
branches/release/boost/ (props changed)
branches/release/boost/unordered/ (props changed)
branches/release/libs/ (props changed)
branches/release/libs/unordered/ (props changed)
Text files modified:
branches/release/boost/unordered/detail/allocate.hpp | 136 ++++++++++++++++++++++++---------------
branches/release/libs/unordered/test/objects/test.hpp | 7 +
branches/release/libs/unordered/test/unordered/at_tests.cpp | 10 ++
3 files changed, 100 insertions(+), 53 deletions(-)
Modified: branches/release/boost/unordered/detail/allocate.hpp
==============================================================================
--- branches/release/boost/unordered/detail/allocate.hpp (original)
+++ branches/release/boost/unordered/detail/allocate.hpp 2012-08-05 04:34:44 EDT (Sun, 05 Aug 2012)
@@ -346,19 +346,20 @@
template <typename A, typename B, typename A0, typename A1, typename A2>
inline typename enable_if<piecewise3<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address, A0&&, A1&& a1, A2&& a2)
+ construct_impl(std::pair<A, B>* address,
+ BOOST_FWD_REF(A0), BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
{
boost::unordered::detail::construct_from_tuple(
- boost::addressof(address->first), a1);
+ boost::addressof(address->first), boost::forward<A1>(a1));
boost::unordered::detail::construct_from_tuple(
- boost::addressof(address->second), a2);
+ boost::addressof(address->second), boost::forward<A2>(a2));
}
#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
template <typename A, typename B, typename A0>
inline typename enable_if<emulation1<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address, A0&& a0)
+ construct_impl(std::pair<A, B>* address, BOOST_FWD_REF(A0) a0)
{
new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
new((void*) boost::addressof(address->second)) B();
@@ -366,7 +367,8 @@
template <typename A, typename B, typename A0, typename A1, typename A2>
inline typename enable_if<emulation3<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address, A0&& a0, A1&& a1, A2&& a2)
+ construct_impl(std::pair<A, B>* address,
+ BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
{
new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
new((void*) boost::addressof(address->second)) B(
@@ -378,7 +380,8 @@
typename A0, typename A1, typename A2, typename A3,
typename... Args>
inline void construct_impl(std::pair<A, B>* address,
- A0&& a0, A1&& a1, A2&& a2, A3&& a3, Args&&... args)
+ BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2,
+ BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(Args)... args)
{
new((void*) boost::addressof(address->first)) A(boost::forward<A0>(a0));
@@ -390,6 +393,7 @@
}
#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
+
#else // BOOST_NO_VARIADIC_TEMPLATES
////////////////////////////////////////////////////////////////////////////////
@@ -441,9 +445,9 @@
#undef BOOST_UNORDERED_CONSTRUCT_IMPL
template <typename A, typename B, typename A0, typename A1, typename A2>
- inline typename enable_if<piecewise3<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address,
- boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+ inline void construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+ typename enable_if<piecewise3<A, B, A0>, void*>::type = 0)
{
boost::unordered::detail::construct_from_tuple(
boost::addressof(address->first), args.a1);
@@ -454,9 +458,9 @@
#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
template <typename A, typename B, typename A0>
- inline typename enable_if<emulation1<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address,
- boost::unordered::detail::emplace_args1<A0> const& args)
+ inline void construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args1<A0> const& args,
+ typename enable_if<emulation1<A, B, A0>, void*>::type = 0)
{
new((void*) boost::addressof(address->first)) A(
boost::forward<A0>(args.a0));
@@ -464,9 +468,9 @@
}
template <typename A, typename B, typename A0, typename A1, typename A2>
- inline typename enable_if<emulation3<A, B, A0>, void>::type
- construct_impl(std::pair<A, B>* address,
- boost::unordered::detail::emplace_args3<A0, A1, A2> const& args)
+ inline void construct_impl(std::pair<A, B>* address,
+ boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
+ typename enable_if<emulation3<A, B, A0>, void*>::type = 0)
{
new((void*) boost::addressof(address->first)) A(
boost::forward<A0>(args.a0));
@@ -811,35 +815,38 @@
# endif
template <typename Alloc>
- inline typename boost::enable_if_c<
+ inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+ typename boost::enable_if_c<
boost::unordered::detail::
- has_select_on_container_copy_construction<Alloc>::value, Alloc
- >::type call_select_on_container_copy_construction(const Alloc& rhs)
+ has_select_on_container_copy_construction<Alloc>::value, void*
+ >::type = 0)
{
return rhs.select_on_container_copy_construction();
}
template <typename Alloc>
- inline typename boost::disable_if_c<
+ inline Alloc call_select_on_container_copy_construction(const Alloc& rhs,
+ typename boost::disable_if_c<
boost::unordered::detail::
- has_select_on_container_copy_construction<Alloc>::value, Alloc
- >::type call_select_on_container_copy_construction(const Alloc& rhs)
+ has_select_on_container_copy_construction<Alloc>::value, void*
+ >::type = 0)
{
return rhs;
}
template <typename SizeType, typename Alloc>
- inline typename boost::enable_if_c<
- boost::unordered::detail::has_max_size<Alloc>::value, SizeType
- >::type call_max_size(const Alloc& a)
+ inline SizeType call_max_size(const Alloc& a,
+ typename boost::enable_if_c<
+ boost::unordered::detail::has_max_size<Alloc>::value, void*
+ >::type = 0)
{
return a.max_size();
}
template <typename SizeType, typename Alloc>
- inline typename boost::disable_if_c<
- boost::unordered::detail::has_max_size<Alloc>::value, SizeType
- >::type call_max_size(const Alloc&)
+ inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
+ boost::unordered::detail::has_max_size<Alloc>::value, void*
+ >::type = 0)
{
return (std::numeric_limits<SizeType>::max)();
}
@@ -967,41 +974,41 @@
// the only construct method that old fashioned allocators support.
template <typename T>
- static typename boost::enable_if_c<
- boost::unordered::detail::has_construct<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
- construct(Alloc& a, T* p, T const& x)
+ static void construct(Alloc& a, T* p, T const& x,
+ typename boost::enable_if_c<
+ boost::unordered::detail::has_construct<Alloc, T>::value &&
+ boost::is_same<T, value_type>::value,
+ void*>::type = 0)
{
a.construct(p, x);
}
template <typename T>
- static typename boost::disable_if_c<
+ static void construct(Alloc&, T* p, T const& x,
+ typename boost::disable_if_c<
boost::unordered::detail::has_construct<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
- construct(Alloc&, T* p, T const& x)
+ boost::is_same<T, value_type>::value,
+ void*>::type = 0)
{
new ((void*) p) T(x);
}
template <typename T>
- static typename boost::enable_if_c<
+ static void destroy(Alloc& a, T* p,
+ typename boost::enable_if_c<
boost::unordered::detail::has_destroy<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
- destroy(Alloc& a, T* p)
+ boost::is_same<T, value_type>::value,
+ void*>::type = 0)
{
a.destroy(p);
}
template <typename T>
- static typename boost::disable_if_c<
+ static void destroy(Alloc&, T* p,
+ typename boost::disable_if_c<
boost::unordered::detail::has_destroy<Alloc, T>::value &&
- boost::is_same<T, value_type>::value
- >::type
- destroy(Alloc&, T* p)
+ boost::is_same<T, value_type>::value,
+ void*>::type = 0)
{
boost::unordered::detail::destroy(p);
}
@@ -1120,17 +1127,42 @@
#else
+ template <typename AllocTraits, typename T>
+ struct value_construct
+ {
+ typedef BOOST_DEDUCED_TYPENAME AllocTraits::allocator_type allocator;
+
+ allocator& alloc;
+ T* ptr;
+
+ value_construct(allocator& a, T* p) : alloc(a), ptr(p)
+ {
+ AllocTraits::construct(alloc, ptr, T());
+ }
+
+ void release()
+ {
+ ptr = 0;
+ }
+
+ ~value_construct()
+ {
+ if (ptr) AllocTraits::destroy(alloc, ptr);
+ }
+
+ private:
+ value_construct(value_construct const&);
+ value_construct& operator=(value_construct const&);
+ };
+
template <typename Alloc, typename T, BOOST_UNORDERED_EMPLACE_TEMPLATE>
inline void construct_node(Alloc& a, T* p, BOOST_UNORDERED_EMPLACE_ARGS)
{
- boost::unordered::detail::allocator_traits<Alloc>::construct(a, p, T());
- try {
- boost::unordered::detail::construct_impl(
- p->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
- } catch(...) {
- boost::unordered::detail::allocator_traits<Alloc>::destroy(a, p);
- throw;
- }
+ value_construct<boost::unordered::detail::allocator_traits<Alloc>, T>
+ construct_guard(a, p);
+ boost::unordered::detail::construct_impl(
+ p->value_ptr(), BOOST_UNORDERED_EMPLACE_FORWARD);
+ construct_guard.release();
}
template <typename Alloc, typename T>
Modified: branches/release/libs/unordered/test/objects/test.hpp
==============================================================================
--- branches/release/libs/unordered/test/objects/test.hpp (original)
+++ branches/release/libs/unordered/test/objects/test.hpp 2012-08-05 04:34:44 EDT (Sun, 05 Aug 2012)
@@ -26,7 +26,9 @@
template <class T> class allocator2;
object generate(object const*);
implicitly_convertible generate(implicitly_convertible const*);
-
+
+ inline void ignore_variable(void const*) {}
+
class object : private counted_object
{
friend class hash;
@@ -248,6 +250,9 @@
void destroy(T* p) {
//detail::tracker.track_destroy((void*) p, sizeof(T), tag_);
p->~T();
+
+ // Work around MSVC buggy unused parameter warning.
+ ignore_variable(&p);
}
bool operator==(allocator1 const& x) const
Modified: branches/release/libs/unordered/test/unordered/at_tests.cpp
==============================================================================
--- branches/release/libs/unordered/test/unordered/at_tests.cpp (original)
+++ branches/release/libs/unordered/test/unordered/at_tests.cpp 2012-08-05 04:34:44 EDT (Sun, 05 Aug 2012)
@@ -13,21 +13,31 @@
namespace at_tests {
UNORDERED_AUTO_TEST(at_tests) {
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
+
boost::unordered_map<std::string, int> x;
typedef boost::unordered_map<std::string, int>::iterator iterator;
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Add elements" << std::endl;
+
x["one"] = 1;
x["two"] = 2;
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check existing elements" << std::endl;
+
BOOST_TEST(x.at("one") == 1);
BOOST_TEST(x.at("two") == 2);
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check missing element" << std::endl;
+
try {
x.at("three");
BOOST_ERROR("Should have thrown.");
}
catch(std::out_of_range) {
}
+
+ BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
}
}
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