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

Unordered: Use a SFINAE parameter rather than return type for C++03 compilers.

Browse Source 
Seems that g++ 3.4 has problems with overloads that are only distinguished by
SFINAE return types.

[SVN r79762]
This commit is contained in:
Daniel James
2012-07-26 22:23:09 +00:00
parent 61516be1db
commit 918b3da91d
1 changed files with 42 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -390,6 +390,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
} }
#endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT #endif // BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT
#else // BOOST_NO_VARIADIC_TEMPLATES #else // BOOST_NO_VARIADIC_TEMPLATES
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -441,9 +442,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
#undef BOOST_UNORDERED_CONSTRUCT_IMPL #undef BOOST_UNORDERED_CONSTRUCT_IMPL
template <typename A, typename B, typename A0, typename A1, typename A2> template <typename A, typename B, typename A0, typename A1, typename A2>
inline typename enable_if<piecewise3<A, B, A0>, void>::type inline void construct_impl(std::pair<A, B>* address,
construct_impl(std::pair<A, B>* address, boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
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::unordered::detail::construct_from_tuple(
boost::addressof(address->first), args.a1); boost::addressof(address->first), args.a1);
@ -454,9 +455,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
#if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT) #if defined(BOOST_UNORDERED_DEPRECATED_PAIR_CONSTRUCT)
template <typename A, typename B, typename A0> template <typename A, typename B, typename A0>
inline typename enable_if<emulation1<A, B, A0>, void>::type inline void construct_impl(std::pair<A, B>* address,
construct_impl(std::pair<A, B>* address, boost::unordered::detail::emplace_args1<A0> const& args,
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( new((void*) boost::addressof(address->first)) A(
boost::forward<A0>(args.a0)); boost::forward<A0>(args.a0));
@ -464,9 +465,9 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, boost::)
} }
template <typename A, typename B, typename A0, typename A1, typename A2> template <typename A, typename B, typename A0, typename A1, typename A2>
inline typename enable_if<emulation3<A, B, A0>, void>::type inline void construct_impl(std::pair<A, B>* address,
construct_impl(std::pair<A, B>* address, boost::unordered::detail::emplace_args3<A0, A1, A2> const& args,
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( new((void*) boost::addressof(address->first)) A(
boost::forward<A0>(args.a0)); boost::forward<A0>(args.a0));
@ -811,35 +812,38 @@ namespace boost { namespace unordered { namespace detail {
# endif # endif
template <typename Alloc> 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:: boost::unordered::detail::
has_select_on_container_copy_construction<Alloc>::value, Alloc has_select_on_container_copy_construction<Alloc>::value, void*
>::type call_select_on_container_copy_construction(const Alloc& rhs) >::type = 0)
{ {
return rhs.select_on_container_copy_construction(); return rhs.select_on_container_copy_construction();
} }
template <typename Alloc> 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:: boost::unordered::detail::
has_select_on_container_copy_construction<Alloc>::value, Alloc has_select_on_container_copy_construction<Alloc>::value, void*
>::type call_select_on_container_copy_construction(const Alloc& rhs) >::type = 0)
{ {
return rhs; return rhs;
} }
template <typename SizeType, typename Alloc> template <typename SizeType, typename Alloc>
inline typename boost::enable_if_c< inline SizeType call_max_size(const Alloc& a,
boost::unordered::detail::has_max_size<Alloc>::value, SizeType typename boost::enable_if_c<
>::type call_max_size(const Alloc& a) boost::unordered::detail::has_max_size<Alloc>::value, void*
>::type = 0)
{ {
return a.max_size(); return a.max_size();
} }
template <typename SizeType, typename Alloc> template <typename SizeType, typename Alloc>
inline typename boost::disable_if_c< inline SizeType call_max_size(const Alloc&, typename boost::disable_if_c<
boost::unordered::detail::has_max_size<Alloc>::value, SizeType boost::unordered::detail::has_max_size<Alloc>::value, void*
>::type call_max_size(const Alloc&) >::type = 0)
{ {
return (std::numeric_limits<SizeType>::max)(); return (std::numeric_limits<SizeType>::max)();
} }
@ -967,41 +971,41 @@ namespace boost { namespace unordered { namespace detail {
// the only construct method that old fashioned allocators support. // the only construct method that old fashioned allocators support.
template <typename T> template <typename T>
static typename boost::enable_if_c< static void construct(Alloc& a, T* p, T const& x,
boost::unordered::detail::has_construct<Alloc, T>::value && typename boost::enable_if_c<
boost::is_same<T, value_type>::value boost::unordered::detail::has_construct<Alloc, T>::value &&
>::type boost::is_same<T, value_type>::value,
construct(Alloc& a, T* p, T const& x) void*>::type = 0)
{ {
a.construct(p, x); a.construct(p, x);
} }
template <typename T> 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::unordered::detail::has_construct<Alloc, T>::value &&
boost::is_same<T, value_type>::value boost::is_same<T, value_type>::value,
>::type void*>::type = 0)
construct(Alloc&, T* p, T const& x)
{ {
new ((void*) p) T(x); new ((void*) p) T(x);
} }
template <typename T> 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::unordered::detail::has_destroy<Alloc, T>::value &&
boost::is_same<T, value_type>::value boost::is_same<T, value_type>::value,
>::type void*>::type = 0)
destroy(Alloc& a, T* p)
{ {
a.destroy(p); a.destroy(p);
} }
template <typename T> 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::unordered::detail::has_destroy<Alloc, T>::value &&
boost::is_same<T, value_type>::value boost::is_same<T, value_type>::value,
>::type void*>::type = 0)
destroy(Alloc&, T* p)
{ {
boost::unordered::detail::destroy(p); boost::unordered::detail::destroy(p);
} }