replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

I believe tuple is still under development in the standard. Daniel Krugler is/will be making convincing arguments that a modified form of LWG 2051 (currently NAD Future) is easily acheivable and desirable. He has demonstrated that a tuple<T...> where all of the T are implicitly convertible from U... should have a tuple constructor that is also implicit, instead of explicit. This would support the use cases in LWG 2051 while not undermining T... with explicit conversions from U.... This check-in is an experimental implementation of Daniel's work. I believe this work to be mature enough to warrant inclusion into libc++. If anyone sees real-world problems that this check in causes, please let me know and I will revert it, and provide the feedback to the LWG. 

llvm-svn: 153855
This commit is contained in:
Howard Hinnant 2012-04-01 23:10:42 +00:00
parent 0090df24d7
commit 0527c6207a
4 changed files with 105 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
libcxx/include/__tuple
View File

@ -216,7 +216,7 @@ struct __tuple_convertible_imp : public false_type {};
template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
: public integral_constant<bool,
is_constructible<_Up0, _Tp0>::value &&
is_convertible<_Tp0, _Up0>::value &&
__tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
template <>
@ -235,6 +235,33 @@ struct __tuple_convertible<_Tp, _Up, true, true>
typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
{};
// __tuple_constructible
template <bool, class _Tp, class _Up>
struct __tuple_constructible_imp : public false_type {};
template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
struct __tuple_constructible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
: public integral_constant<bool,
is_constructible<_Up0, _Tp0>::value &&
__tuple_constructible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
template <>
struct __tuple_constructible_imp<true, __tuple_types<>, __tuple_types<> >
: public true_type {};
template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
bool = __tuple_like<_Up>::value>
struct __tuple_constructible
: public false_type {};
template <class _Tp, class _Up>
struct __tuple_constructible<_Tp, _Up, true, true>
: public __tuple_constructible_imp<tuple_size<typename remove_reference<_Tp>::type>::value ==
tuple_size<_Up>::value,
typename __make_tuple_types<_Tp>::type, typename __make_tuple_types<_Up>::type>
{};
// __tuple_assignable
template <bool, class _Tp, class _Up>

58
libcxx/include/tuple
View File

@ -552,7 +552,7 @@ public:
) {}
template <class ..._Up,
class = typename enable_if
typename enable_if
<
sizeof...(_Up) <= sizeof...(_Tp) &&
__tuple_convertible
@ -562,8 +562,40 @@ public:
sizeof...(_Up) < sizeof...(_Tp) ?
sizeof...(_Up) :
sizeof...(_Tp)>::type
>::value
>::type
>::value,
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY
tuple(_Up&&... __u)
: base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
_VSTD::forward<_Up>(__u)...) {}
template <class ..._Up,
typename enable_if
<
sizeof...(_Up) <= sizeof...(_Tp) &&
__tuple_constructible
<
tuple<_Up...>,
typename __make_tuple_types<tuple,
sizeof...(_Up) < sizeof...(_Tp) ?
sizeof...(_Up) :
sizeof...(_Tp)>::type
>::value &&
!__tuple_convertible
<
tuple<_Up...>,
typename __make_tuple_types<tuple,
sizeof...(_Up) < sizeof...(_Tp) ?
sizeof...(_Up) :
sizeof...(_Tp)>::type
>::value,
bool
>::type =false
>
_LIBCPP_INLINE_VISIBILITY
explicit
@ -598,15 +630,29 @@ public:
_VSTD::forward<_Up>(__u)...) {}
template <class _Tuple,
class = typename enable_if
typename enable_if
<
__tuple_convertible<_Tuple, tuple>::value
>::type
__tuple_convertible<_Tuple, tuple>::value,
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY
tuple(_Tuple&& __t)
: base_(_VSTD::forward<_Tuple>(__t)) {}
template <class _Tuple,
typename enable_if
<
__tuple_constructible<_Tuple, tuple>::value &&
!__tuple_convertible<_Tuple, tuple>::value,
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY
explicit
tuple(_Tuple&& __t)
: base_(_VSTD::forward<_Tuple>(__t)) {}
template <class _Alloc, class _Tuple,
class = typename enable_if
<

26
libcxx/test/utilities/tuple/tuple.tuple/tuple.cnstr/UTypes.fail.cpp
View File

@ -14,14 +14,36 @@
// template <class... UTypes>
// explicit tuple(UTypes&&... u);
/*
This is testing an extension whereby only Types having an explicit conversion
from UTypes are bound by the explicit tuple constructor.
*/
#include <tuple>
#include <cassert>
#include "../MoveOnly.h"
class MoveOnly
{
MoveOnly(const MoveOnly&);
MoveOnly& operator=(const MoveOnly&);
int data_;
public:
explicit MoveOnly(int data = 1) : data_(data) {}
MoveOnly(MoveOnly&& x)
: data_(x.data_) {x.data_ = 0;}
MoveOnly& operator=(MoveOnly&& x)
{data_ = x.data_; x.data_ = 0; return *this;}
int get() const {return data_;}
bool operator==(const MoveOnly& x) const {return data_ == x.data_;}
bool operator< (const MoveOnly& x) const {return data_ < x.data_;}
};
int main()
{
{
std::tuple<MoveOnly> t = MoveOnly(0);
std::tuple<MoveOnly> t = 1;
}
}

3
libcxx/test/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.fail.cpp
View File

@ -20,7 +20,6 @@
int main()
{
{
std::tuple<int> t = 2;
assert(std::get<0>(t) == 2);
std::tuple<int*> t = 0;
}
}