feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Unordered: Use Boost.Move in a few more places.

Browse Source 
Should be better for compilers with variadic parameters, but no rvalue
references. If such a thing ever exists.

[SVN r78536]
This commit is contained in:
Daniel James
2012-05-21 22:15:33 +00:00
parent c6f0175c79
commit 1eac47a275
12 changed files with 62 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
include/boost/unordered/detail/allocate.hpp
View File

@ -45,11 +45,6 @@
#define BOOST_UNORDERED_EMPLACE_LIMIT 10 #define BOOST_UNORDERED_EMPLACE_LIMIT 10
#if !defined(BOOST_NO_RVALUE_REFERENCES) && \
!defined(BOOST_NO_VARIADIC_TEMPLATES)
#define BOOST_UNORDERED_VARIADIC_MOVE
#endif
namespace boost { namespace unordered { namespace detail { namespace boost { namespace unordered { namespace detail {
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
@ -90,10 +85,10 @@ namespace boost { namespace unordered { namespace detail {
// Either forwarding variadic arguments, or storing the arguments in // Either forwarding variadic arguments, or storing the arguments in
// emplace_args##n // emplace_args##n
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
#define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args #define BOOST_UNORDERED_EMPLACE_TEMPLATE typename... Args
#define BOOST_UNORDERED_EMPLACE_ARGS Args&&... args #define BOOST_UNORDERED_EMPLACE_ARGS BOOST_FWD_REF(Args)... args
#define BOOST_UNORDERED_EMPLACE_FORWARD boost::forward<Args>(args)... #define BOOST_UNORDERED_EMPLACE_FORWARD boost::forward<Args>(args)...
#else #else
@ -330,13 +325,13 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
#endif #endif
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Construct from variadic parameters // Construct from variadic parameters
template <typename T, typename... Args> template <typename T, typename... Args>
inline void construct_impl(T* address, Args&&... args) inline void construct_impl(T* address, BOOST_FWD_REF(Args)... args)
{ {
new((void*) address) T(boost::forward<Args>(args)...); new((void*) address) T(boost::forward<Args>(args)...);
} }
@ -387,7 +382,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
} }
#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT #endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
#else // BOOST_UNORDERED_VARIADIC_MOVE #else // BOOST_NO_VARIADIC_TEMPLATES
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// Construct from emplace_args // Construct from emplace_args
@ -499,7 +494,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
#undef BOOST_UNORDERED_CALL_FORWARD2 #undef BOOST_UNORDERED_CALL_FORWARD2
#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT #endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
#endif // BOOST_UNORDERED_VARIADIC_MOVE #endif // BOOST_NO_VARIADIC_TEMPLATES
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Construct without using the emplace args mechanism. // Construct without using the emplace args mechanism.
@ -525,7 +520,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
#if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS) #if !defined(BOOST_UNORDERED_USE_ALLOCATOR_TRAITS)
# if defined(__GXX_EXPERIMENTAL_CXX0X__) && \ # if defined(__GXX_EXPERIMENTAL_CXX0X__) && \
(__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)) (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))
# define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 1 # define BOOST_UNORDERED_USE_ALLOCATOR_TRAITS 0
# elif defined(BOOST_MSVC) # elif defined(BOOST_MSVC)
# if BOOST_MSVC < 1400 # if BOOST_MSVC < 1400
// Use container's allocator_traits for older versions of Visual // Use container's allocator_traits for older versions of Visual
@ -689,7 +684,7 @@ namespace boost { namespace unordered { namespace detail {
# include <boost/type_traits/is_same.hpp> # include <boost/type_traits/is_same.hpp>
# endif # endif
# if defined(BOOST_UNORDERED_VARIADIC_MOVE) && \ # if !defined(BOOST_NO_VARIADIC_TEMPLATES) && \
!defined(BOOST_NO_SFINAE_EXPR) !defined(BOOST_NO_SFINAE_EXPR)
# define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1 # define BOOST_UNORDERED_DETAIL_FULL_CONSTRUCT 1
# else # else
@ -779,7 +774,7 @@ namespace boost { namespace unordered { namespace detail {
max_size, U const, (), 0 max_size, U const, (), 0
); );
# if defined(BOOST_UNORDERED_VARIADIC_MOVE) # if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <typename T, typename ValueType, typename... Args> template <typename T, typename ValueType, typename... Args>
BOOST_UNORDERED_HAS_FUNCTION( BOOST_UNORDERED_HAS_FUNCTION(
@ -906,7 +901,7 @@ namespace boost { namespace unordered { namespace detail {
static typename boost::enable_if_c< static typename boost::enable_if_c<
boost::unordered::detail::has_construct<Alloc, T, Args...> boost::unordered::detail::has_construct<Alloc, T, Args...>
::value>::type ::value>::type
construct(Alloc& a, T* p, Args&&... x) construct(Alloc& a, T* p, BOOST_FWD_REF(Args)... x)
{ {
a.construct(p, boost::forward<Args>(x)...); a.construct(p, boost::forward<Args>(x)...);
} }
@ -915,7 +910,7 @@ namespace boost { namespace unordered { namespace detail {
static typename boost::disable_if_c< static typename boost::disable_if_c<
boost::unordered::detail::has_construct<Alloc, T, Args...> boost::unordered::detail::has_construct<Alloc, T, Args...>
::value>::type ::value>::type
construct(Alloc&, T* p, Args&&... x) construct(Alloc&, T* p, BOOST_FWD_REF(Args)... x)
{ {
new ((void*) p) T(boost::forward<Args>(x)...); new ((void*) p) T(boost::forward<Args>(x)...);
} }

2
include/boost/unordered/detail/buckets.hpp
View File

@ -82,7 +82,7 @@ namespace boost { namespace unordered { namespace detail {
void construct_value2(BOOST_FWD_REF(A0) a0) void construct_value2(BOOST_FWD_REF(A0) a0)
{ {
BOOST_ASSERT(node_ && !constructed_); BOOST_ASSERT(node_ && !constructed_);
# if defined(BOOST_UNORDERED_VARIADIC_MOVE) # if !defined(BOOST_NO_VARIADIC_TEMPLATES)
boost::unordered::detail::construct_node(alloc_, boost::unordered::detail::construct_node(alloc_,
boost::addressof(*node_), boost::forward<A0>(a0)); boost::addressof(*node_), boost::forward<A0>(a0));
# else # else

9
include/boost/unordered/detail/equivalent.hpp
View File

@ -497,12 +497,21 @@ namespace boost { namespace unordered { namespace detail {
} }
#if defined(BOOST_NO_RVALUE_REFERENCES) #if defined(BOOST_NO_RVALUE_REFERENCES)
# if defined(BOOST_NO_VARIADIC_TEMPLATES)
iterator emplace(boost::unordered::detail::emplace_args1< iterator emplace(boost::unordered::detail::emplace_args1<
boost::unordered::detail::please_ignore_this_overload> const&) boost::unordered::detail::please_ignore_this_overload> const&)
{ {
BOOST_ASSERT(false); BOOST_ASSERT(false);
return iterator(); return iterator();
} }
# else
iterator emplace(
boost::unordered::detail::please_ignore_this_overload const&)
{
BOOST_ASSERT(false);
return iterator();
}
# endif
#endif #endif
template <BOOST_UNORDERED_EMPLACE_TEMPLATE> template <BOOST_UNORDERED_EMPLACE_TEMPLATE>

10
include/boost/unordered/detail/extract_key.hpp
View File

@ -56,7 +56,7 @@ namespace detail {
return no_key(); return no_key();
} }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class... Args> template <class... Args>
static no_key extract(Args const&...) static no_key extract(Args const&...)
{ {
@ -111,7 +111,7 @@ namespace detail {
return v.first; return v.first;
} }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class Arg1, class... Args> template <class Arg1, class... Args>
static key_type const& extract(key_type const& k, static key_type const& extract(key_type const& k,
Arg1 const&, Args const&...) Arg1 const&, Args const&...)
@ -150,12 +150,12 @@ namespace detail {
} }
#endif #endif
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
#define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_) \ #define BOOST_UNORDERED_KEY_FROM_TUPLE(namespace_) \
template <typename T2> \ template <typename T2> \
static no_key extract(boost::unordered::piecewise_construct_t, \ static no_key extract(boost::unordered::piecewise_construct_t, \
namespace_::tuple<> const&, T2&&) \ namespace_::tuple<> const&, BOOST_FWD_REF(T2)) \
{ \ { \
return no_key(); \ return no_key(); \
} \ } \
@ -163,7 +163,7 @@ namespace detail {
template <typename T, typename T2> \ template <typename T, typename T2> \
static typename is_key<key_type, T>::type \ static typename is_key<key_type, T>::type \
extract(boost::unordered::piecewise_construct_t, \ extract(boost::unordered::piecewise_construct_t, \
namespace_::tuple<T> const& k, T2&&) \ namespace_::tuple<T> const& k, BOOST_FWD_REF(T2)) \
{ \ { \
return typename is_key<key_type, T>::type( \ return typename is_key<key_type, T>::type( \
namespace_::get<0>(k)); \ namespace_::get<0>(k)); \

16
include/boost/unordered/detail/unique.hpp
View File

@ -379,7 +379,7 @@ namespace boost { namespace unordered { namespace detail {
// exception (need strong safety in such a case). // exception (need strong safety in such a case).
node_constructor a(this->node_alloc()); node_constructor a(this->node_alloc());
a.construct_node(); a.construct_node();
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
a.construct_value(boost::unordered::piecewise_construct, a.construct_value(boost::unordered::piecewise_construct,
boost::make_tuple(k), boost::make_tuple()); boost::make_tuple(k), boost::make_tuple());
#else #else
@ -395,22 +395,30 @@ namespace boost { namespace unordered { namespace detail {
} }
#if defined(BOOST_NO_RVALUE_REFERENCES) #if defined(BOOST_NO_RVALUE_REFERENCES)
# if defined(BOOST_NO_VARIADIC_TEMPLATES)
emplace_return emplace(boost::unordered::detail::emplace_args1< emplace_return emplace(boost::unordered::detail::emplace_args1<
boost::unordered::detail::please_ignore_this_overload> const&) boost::unordered::detail::please_ignore_this_overload> const&)
{ {
BOOST_ASSERT(false); BOOST_ASSERT(false);
return emplace_return(this->begin(), false); return emplace_return(this->begin(), false);
} }
# else
emplace_return emplace(
boost::unordered::detail::please_ignore_this_overload const&)
{
BOOST_ASSERT(false);
return emplace_return(this->begin(), false);
}
# endif
#endif #endif
template <BOOST_UNORDERED_EMPLACE_TEMPLATE> template <BOOST_UNORDERED_EMPLACE_TEMPLATE>
emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS) emplace_return emplace(BOOST_UNORDERED_EMPLACE_ARGS)
{ {
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
return emplace_impl( return emplace_impl(
extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD), extractor::extract(BOOST_UNORDERED_EMPLACE_FORWARD),
BOOST_UNORDERED_EMPLACE_FORWARD); BOOST_UNORDERED_EMPLACE_FORWARD);
#else #else
return emplace_impl( return emplace_impl(
extractor::extract(args.a0, args.a1), extractor::extract(args.a0, args.a1),
@ -418,7 +426,7 @@ namespace boost { namespace unordered { namespace detail {
#endif #endif
} }
#if !defined(BOOST_UNORDERED_VARIADIC_MOVE) #if defined(BOOST_NO_VARIADIC_TEMPLATES)
template <typename A0> template <typename A0>
emplace_return emplace( emplace_return emplace(
boost::unordered::detail::emplace_args1<A0> const& args) boost::unordered::detail::emplace_args1<A0> const& args)

12
include/boost/unordered/unordered_map.hpp
View File

@ -232,15 +232,15 @@ namespace unordered
// emplace // emplace
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class... Args> template <class... Args>
std::pair<iterator, bool> emplace(Args&&... args) std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }
template <class... Args> template <class... Args>
iterator emplace_hint(const_iterator, Args&&... args) iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...).first; return table_.emplace(boost::forward<Args>(args)...).first;
} }
@ -719,15 +719,15 @@ namespace unordered
// emplace // emplace
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class... Args> template <class... Args>
iterator emplace(Args&&... args) iterator emplace(BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }
template <class... Args> template <class... Args>
iterator emplace_hint(const_iterator, Args&&... args) iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }

12
include/boost/unordered/unordered_set.hpp
View File

@ -230,15 +230,15 @@ namespace unordered
// emplace // emplace
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class... Args> template <class... Args>
std::pair<iterator, bool> emplace(Args&&... args) std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }
template <class... Args> template <class... Args>
iterator emplace_hint(const_iterator, Args&&... args) iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...).first; return table_.emplace(boost::forward<Args>(args)...).first;
} }
@ -703,15 +703,15 @@ namespace unordered
// emplace // emplace
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template <class... Args> template <class... Args>
iterator emplace(Args&&... args) iterator emplace(BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }
template <class... Args> template <class... Args>
iterator emplace_hint(const_iterator, Args&&... args) iterator emplace_hint(const_iterator, BOOST_FWD_REF(Args)... args)
{ {
return table_.emplace(boost::forward<Args>(args)...); return table_.emplace(boost::forward<Args>(args)...);
} }

4
test/objects/cxx11_allocator.hpp
View File

@ -168,8 +168,8 @@ namespace test
new(p) T(t); new(p) T(t);
} }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template<typename... Args> void construct(T* p, Args&&... args) { template<typename... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
detail::tracker.track_construct((void*) p, sizeof(T), tag_); detail::tracker.track_construct((void*) p, sizeof(T), tag_);
new(p) T(boost::forward<Args>(args)...); new(p) T(boost::forward<Args>(args)...);
} }

6
test/objects/exception.hpp
View File

@ -357,9 +357,9 @@ namespace exception
detail::tracker.track_construct((void*) p, sizeof(T), tag_); detail::tracker.track_construct((void*) p, sizeof(T), tag_);
} }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template<class... Args> void construct(T* p, Args&&... args) { template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
UNORDERED_SCOPE(allocator::construct(pointer, Args&&...)) { UNORDERED_SCOPE(allocator::construct(pointer, BOOST_FWD_REF(Args)...)) {
UNORDERED_EPOINT("Mock allocator construct function."); UNORDERED_EPOINT("Mock allocator construct function.");
new(p) T(boost::forward<Args>(args)...); new(p) T(boost::forward<Args>(args)...);
} }

8
test/objects/minimal.hpp
View File

@ -367,8 +367,8 @@ namespace minimal
void construct(T* p, T const& t) { new((void*)p) T(t); } void construct(T* p, T const& t) { new((void*)p) T(t); }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template<class... Args> void construct(T* p, Args&&... args) { template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
new((void*)p) T(boost::forward<Args>(args)...); new((void*)p) T(boost::forward<Args>(args)...);
} }
#endif #endif
@ -439,8 +439,8 @@ namespace minimal
void construct(T* p, T const& t) { new((void*)p) T(t); } void construct(T* p, T const& t) { new((void*)p) T(t); }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template<class... Args> void construct(T* p, Args&&... args) { template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
new((void*)p) T(boost::forward<Args>(args)...); new((void*)p) T(boost::forward<Args>(args)...);
} }
#endif #endif

4
test/objects/test.hpp
View File

@ -259,8 +259,8 @@ namespace test
new(p) T(t); new(p) T(t);
} }
#if defined(BOOST_UNORDERED_VARIADIC_MOVE) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
template<class... Args> void construct(T* p, Args&&... args) { template<class... Args> void construct(T* p, BOOST_FWD_REF(Args)... args) {
detail::tracker.track_construct((void*) p, sizeof(T), tag_); detail::tracker.track_construct((void*) p, sizeof(T), tag_);
new(p) T(boost::forward<Args>(args)...); new(p) T(boost::forward<Args>(args)...);
} }

19
test/unordered/unnecessary_copy_tests.cpp
View File

@ -11,23 +11,6 @@
#include <iostream> #include <iostream>
#include "../helpers/test.hpp" #include "../helpers/test.hpp"
#if defined(BOOST_UNORDERED_VARIADIC_MOVE)
# if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
# elif defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
# elif defined(_LIBCPP_VERSION)
# define BOOST_UNORDERED_VARIADIC_MOVE
# elif defined(__GLIBCPP__) || defined(__GLIBCXX__)
# if defined(__GLIBCXX__) && __GLIBCXX__ >= 20090804
# define BOOST_UNORDERED_VARIADIC_MOVE
# endif
# elif defined(__STL_CONFIG_H)
# elif defined(__MSL_CPP__)
# elif defined(__IBMCPP__)
# elif defined(MSIPL_COMPILE_H)
# elif (defined(_YVALS) && !defined(__IBMCPP__)) || defined(_CPPLIB_VER)
# endif
#endif
namespace unnecessary_copy_tests namespace unnecessary_copy_tests
{ {
struct count_copies struct count_copies
@ -262,7 +245,7 @@ namespace unnecessary_copy_tests
// the existing element. // the existing element.
reset(); reset();
x.emplace(); x.emplace();
#if !defined(BOOST_NO_RVALUE_REFERENCES) #if !defined(BOOST_NO_VARIADIC_TEMPLATES)
// source_cost doesn't make much sense here, but it seems to fit. // source_cost doesn't make much sense here, but it seems to fit.
COPY_COUNT(1); MOVE_COUNT(source_cost); COPY_COUNT(1); MOVE_COUNT(source_cost);
#else #else