EricWF updated this revision to Diff 80862.
EricWF added a comment.
Cleanup a couple of issues.
https://reviews.llvm.org/D27606
Files:
include/__tuple
include/tuple
include/type_traits
test/std/utilities/tuple/tuple.tuple/tuple.assign/derived_from_tuple_like.pass.cpp
test/std/utilities/tuple/tuple.tuple/tuple.cnstr/derived_from_tuple_like.pass.cpp
test/support/propagate_value_category.hpp
Index: test/support/propagate_value_category.hpp
===================================================================
--- /dev/null
+++ test/support/propagate_value_category.hpp
@@ -0,0 +1,145 @@
+#ifndef TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY
+#define TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY
+
+#include "test_macros.h"
+#include <type_traits>
+
+#if TEST_STD_VER < 11
+#error this header may only be used in C++11
+#endif
+
+using UnderlyingVCType = unsigned;
+enum ValueCategory : UnderlyingVCType {
+ VC_None = 0,
+ VC_LVal = 1 << 0,
+ VC_RVal = 1 << 1,
+ VC_Const = 1 << 2,
+ VC_Volatile = 1 << 3,
+ VC_ConstVolatile = VC_Const | VC_Volatile
+};
+
+inline constexpr ValueCategory operator&(ValueCategory LHS, ValueCategory RHS) {
+ return ValueCategory(LHS & (UnderlyingVCType)RHS);
+}
+
+inline constexpr ValueCategory operator|(ValueCategory LHS, ValueCategory RHS) {
+ return ValueCategory(LHS | (UnderlyingVCType)RHS);
+}
+
+inline constexpr ValueCategory operator^(ValueCategory LHS, ValueCategory RHS) {
+ return ValueCategory(LHS ^ (UnderlyingVCType)RHS);
+}
+
+inline constexpr bool isValidValueCategory(ValueCategory VC) {
+ return (VC & (VC_LVal | VC_RVal)) != (VC_LVal | VC_RVal);
+}
+
+inline constexpr bool hasValueCategory(ValueCategory Arg, ValueCategory Key) {
+ return Arg == Key || ((Arg & Key) == Key);
+}
+
+template <class Tp>
+using UnCVRef =
+ typename std::remove_cv<typename std::remove_reference<Tp>::type>::type;
+
+template <class Tp>
+constexpr ValueCategory getReferenceQuals() {
+ return std::is_lvalue_reference<Tp>::value
+ ? VC_LVal
+ : (std::is_rvalue_reference<Tp>::value ? VC_RVal : VC_None);
+}
+static_assert(getReferenceQuals<int>() == VC_None, "");
+static_assert(getReferenceQuals<int &>() == VC_LVal, "");
+static_assert(getReferenceQuals<int &&>() == VC_RVal, "");
+
+template <class Tp>
+constexpr ValueCategory getCVQuals() {
+ using Vp = typename std::remove_reference<Tp>::type;
+ return std::is_const<Vp>::value && std::is_volatile<Vp>::value
+ ? VC_ConstVolatile
+ : (std::is_const<Vp>::value
+ ? VC_Const
+ : (std::is_volatile<Vp>::value ? VC_Volatile : VC_None));
+}
+static_assert(getCVQuals<int>() == VC_None, "");
+static_assert(getCVQuals<int const>() == VC_Const, "");
+static_assert(getCVQuals<int volatile>() == VC_Volatile, "");
+static_assert(getCVQuals<int const volatile>() == VC_ConstVolatile, "");
+static_assert(getCVQuals<int &>() == VC_None, "");
+static_assert(getCVQuals<int const &>() == VC_Const, "");
+
+template <class Tp>
+inline constexpr ValueCategory getValueCategory() {
+ return getReferenceQuals<Tp>() | getCVQuals<Tp>();
+}
+static_assert(getValueCategory<int>() == VC_None, "");
+static_assert(getValueCategory<int const &>() == (VC_LVal | VC_Const), "");
+static_assert(getValueCategory<int const volatile &&>() ==
+ (VC_RVal | VC_ConstVolatile),
+ "");
+
+template <ValueCategory VC>
+struct ApplyValueCategory {
+private:
+ static_assert(isValidValueCategory(VC), "");
+
+ template <bool Pred, class Then, class Else>
+ using CondT = typename std::conditional<Pred, Then, Else>::type;
+
+public:
+ template <class Tp, class Vp = UnCVRef<Tp>>
+ using ApplyCVQuals = CondT<
+ hasValueCategory(VC, VC_ConstVolatile), typename std::add_cv<Vp>::type,
+ CondT<hasValueCategory(VC, VC_Const), typename std::add_const<Vp>::type,
+ CondT<hasValueCategory(VC, VC_Volatile),
+ typename std::add_volatile<Vp>::type, Tp>>>;
+
+ template <class Tp, class Vp = typename std::remove_reference<Tp>::type>
+ using ApplyReferenceQuals =
+ CondT<hasValueCategory(VC, VC_LVal),
+ typename std::add_lvalue_reference<Vp>::type,
+ CondT<hasValueCategory(VC, VC_RVal),
+ typename std::add_rvalue_reference<Vp>::type, Vp>>;
+
+ template <class Tp>
+ using Apply = ApplyReferenceQuals<ApplyCVQuals<UnCVRef<Tp>>>;
+
+ template <class Tp, bool Dummy = true,
+ typename std::enable_if<Dummy && (VC & VC_LVal), bool>::type = true>
+ static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+ using ToType = Apply<UnCVRef<Tp>>;
+ return static_cast<ToType>(t);
+ }
+
+ template <class Tp, bool Dummy = true,
+ typename std::enable_if<Dummy && (VC & VC_RVal), bool>::type = true>
+ static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+ using ToType = Apply<UnCVRef<Tp>>;
+ return static_cast<ToType>(std::move(t));
+ }
+
+ template <
+ class Tp, bool Dummy = true,
+ typename std::enable_if<Dummy && ((VC & (VC_LVal | VC_RVal)) == VC_None),
+ bool>::type = true>
+ static Apply<UnCVRef<Tp>> cast(Tp &&t) {
+ return t;
+ }
+};
+
+template <ValueCategory VC, class Tp>
+using ApplyValueCategoryT = typename ApplyValueCategory<VC>::template Apply<Tp>;
+
+template <class Tp>
+using PropagateValueCategory = ApplyValueCategory<getValueCategory<Tp>()>;
+
+template <class Tp, class Up>
+using PropagateValueCategoryT =
+ typename ApplyValueCategory<getValueCategory<Tp>()>::template Apply<Up>;
+
+template <ValueCategory VC, class Tp>
+typename ApplyValueCategory<VC>::template Apply<Tp> ValueCategoryCast(Tp &&t) {
+ return ApplyValueCategory<VC>::cast(std::forward<Tp>(t));
+};
+
+#endif // TEST_SUPPORT_PROPAGATE_VALUE_CATEGORY
Index: test/std/utilities/tuple/tuple.tuple/tuple.cnstr/derived_from_tuple_like.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/tuple/tuple.tuple/tuple.cnstr/derived_from_tuple_like.pass.cpp
@@ -0,0 +1,150 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+// tuple& operator=(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <array>
+#include <string>
+#include <utility>
+#include <cassert>
+
+#include "propagate_value_category.hpp"
+
+template <bool Explicit = false>
+struct TracksIntQuals {
+ TracksIntQuals() : value(-1), value_category(VC_None), assigned(false) {}
+
+ template <
+ class Tp,
+ typename std::enable_if<Explicit &&
+ !std::is_same<typename std::decay<Tp>::type,
+ TracksIntQuals>::value,
+ bool>::type = false>
+ explicit TracksIntQuals(Tp &&x)
+ : value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
+ static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+ }
+
+ template <
+ class Tp,
+ typename std::enable_if<!Explicit &&
+ !std::is_same<typename std::decay<Tp>::type,
+ TracksIntQuals>::value,
+ bool>::type = false>
+ TracksIntQuals(Tp &&x)
+ : value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
+ static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+ }
+
+ template <class Tp,
+ class = typename std::enable_if<!std::is_same<
+ typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
+ TracksIntQuals &operator=(Tp &&x) {
+ static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+ value = x;
+ value_category = getValueCategory<Tp &&>();
+ assigned = true;
+ return *this;
+ }
+
+ void reset() {
+ value = -1;
+ value_category = VC_None;
+ assigned = false;
+ }
+
+ bool checkConstruct(int expect, ValueCategory expect_vc) const {
+ return value != 1 && value == expect && value_category == expect_vc &&
+ assigned == false;
+ }
+
+ bool checkAssign(int expect, ValueCategory expect_vc) const {
+ return value != 1 && value == expect && value_category == expect_vc &&
+ assigned == true;
+ }
+
+ int value;
+ ValueCategory value_category;
+ bool assigned;
+};
+
+template <class Tup>
+struct DerivedFromTup : Tup {
+ using Tup::Tup;
+};
+
+template <ValueCategory VC>
+void do_derived_construct_test() {
+ using Tup1 = std::tuple<long, TracksIntQuals</*Explicit*/ false>>;
+ {
+ DerivedFromTup<std::tuple<int, int>> d(42, 101);
+ Tup1 t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+ {
+ DerivedFromTup<std::pair<int, int>> d(42, 101);
+ Tup1 t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+ {
+ DerivedFromTup<std::array<int, 2>> d = {{{42, 101}}};
+ Tup1 t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+
+ using Tup2 = std::tuple<long, TracksIntQuals</*Explicit*/ true>>;
+ {
+ using D = DerivedFromTup<std::tuple<int, int>>;
+ static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+ "");
+ D d(42, 101);
+ Tup2 t(ValueCategoryCast<VC>(d));
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+ {
+ using D = DerivedFromTup<std::pair<int, int>>;
+ static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+ "");
+ D d(42, 101);
+ Tup2 t(ValueCategoryCast<VC>(d));
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+ {
+ using D = DerivedFromTup<std::array<int, 2>>;
+ static_assert(!std::is_convertible<ApplyValueCategoryT<VC, D>, Tup2>::value,
+ "");
+ D d = {{{42, 101}}};
+ Tup2 t(ValueCategoryCast<VC>(d));
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkConstruct(101, VC));
+ }
+}
+
+int main() {
+ do_derived_construct_test<VC_LVal | VC_Const>();
+ do_derived_construct_test<VC_RVal>();
+#if defined(_LIBCPP_VERSION)
+ // Supporting non-const copy and const move are libc++ extensions
+ do_derived_construct_test<VC_LVal>();
+ do_derived_construct_test<VC_RVal | VC_Const>();
+#endif
+}
Index: test/std/utilities/tuple/tuple.tuple/tuple.assign/derived_from_tuple_like.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/tuple/tuple.tuple/tuple.assign/derived_from_tuple_like.pass.cpp
@@ -0,0 +1,113 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <tuple>
+
+// template <class... Types> class tuple;
+
+// template <class... UTypes>
+// tuple& operator=(const tuple<UTypes...>& u);
+
+// UNSUPPORTED: c++98, c++03
+
+#include <tuple>
+#include <array>
+#include <string>
+#include <utility>
+#include <cassert>
+
+#include "propagate_value_category.hpp"
+
+struct TracksIntQuals {
+ TracksIntQuals() : value(-1), value_category(VC_None), assigned(false) {}
+
+ template <class Tp,
+ class = typename std::enable_if<!std::is_same<
+ typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
+ TracksIntQuals(Tp &&x)
+ : value(x), value_category(getValueCategory<Tp &&>()), assigned(false) {
+ static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+ }
+
+ template <class Tp,
+ class = typename std::enable_if<!std::is_same<
+ typename std::decay<Tp>::type, TracksIntQuals>::value>::type>
+ TracksIntQuals &operator=(Tp &&x) {
+ static_assert(std::is_same<UnCVRef<Tp>, int>::value, "");
+ value = x;
+ value_category = getValueCategory<Tp &&>();
+ assigned = true;
+ return *this;
+ }
+
+ void reset() {
+ value = -1;
+ value_category = VC_None;
+ assigned = false;
+ }
+
+ bool checkConstruct(int expect, ValueCategory expect_vc) const {
+ return value != 1 && value == expect && value_category == expect_vc &&
+ assigned == false;
+ }
+
+ bool checkAssign(int expect, ValueCategory expect_vc) const {
+ return value != 1 && value == expect && value_category == expect_vc &&
+ assigned == true;
+ }
+
+ int value;
+ ValueCategory value_category;
+ bool assigned;
+};
+
+template <class Tup>
+struct DerivedFromTup : Tup {
+ using Tup::Tup;
+};
+
+template <ValueCategory VC>
+void do_derived_assign_test() {
+ using Tup1 = std::tuple<long, TracksIntQuals>;
+ Tup1 t;
+ auto reset = [&]() {
+ std::get<0>(t) = -1;
+ std::get<1>(t).reset();
+ };
+ {
+ DerivedFromTup<std::tuple<int, int>> d(42, 101);
+ t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkAssign(101, VC));
+ }
+ reset();
+ {
+ DerivedFromTup<std::pair<int, int>> d(42, 101);
+ t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkAssign(101, VC));
+ }
+ reset();
+ {
+ DerivedFromTup<std::array<int, 2>> d = {{{42, 101}}};
+ t = ValueCategoryCast<VC>(d);
+ assert(std::get<0>(t) == 42);
+ assert(std::get<1>(t).checkAssign(101, VC));
+ }
+}
+
+int main() {
+ do_derived_assign_test<VC_LVal | VC_Const>();
+ do_derived_assign_test<VC_RVal>();
+#if defined(_LIBCPP_VERSION)
+ // Non-const copy assign and const move assign are libc++ extensions.
+ do_derived_assign_test<VC_LVal>();
+ do_derived_assign_test<VC_RVal | VC_Const>();
+#endif
+}
Index: include/type_traits
===================================================================
--- include/type_traits
+++ include/type_traits
@@ -4696,6 +4696,59 @@
#endif
+#ifndef _LIBCPP_CXX03_LANG
+template <class _FromType>
+struct __propagate_value_category {
+ template <class _ToType> struct __checked_apply {
+ static_assert(!is_reference<_ToType>::value, "must be unqualified");
+ static_assert(!is_const<_ToType>::value && !is_volatile<_ToType>::value, "must be unqualified");
+ using type = _ToType;
+ };
+ template <class _ToType>
+ using __apply = typename __checked_apply<_ToType>::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType&> {
+ template <class _ToType>
+ using __apply = typename add_lvalue_reference<
+ typename __propagate_value_category<_FromType>::template __apply<_ToType>
+ >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType&&> {
+ template <class _ToType>
+ using __apply = typename add_rvalue_reference<
+ typename __propagate_value_category<_FromType>::template __apply<_ToType>
+ >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType const> {
+ template <class _ToType>
+ using __apply = typename add_const<
+ typename __propagate_value_category<_FromType>::template __apply<_ToType>
+ >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType volatile> {
+ template <class _ToType>
+ using __apply = typename add_volatile<
+ typename __propagate_value_category<_FromType>::template __apply<_ToType>
+ >::type;
+};
+
+template <class _FromType>
+struct __propagate_value_category<_FromType const volatile> {
+ template <class _ToType>
+ using __apply = typename add_cv<
+ typename __propagate_value_category<_FromType>::template __apply<_ToType>
+ >::type;
+};
+#endif
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_TYPE_TRAITS
Index: include/tuple
===================================================================
--- include/tuple
+++ include/tuple
@@ -555,13 +555,19 @@
{
template <class _Tuple>
static constexpr bool __enable_implicit() {
- return __tuple_convertible<_Tuple, tuple>::value;
+ using _Deduced = __deduce_tuple_like<_Tuple>;
+ using _QualType = typename _Deduced::_QualType;
+ static_assert(__tuple_like<typename _Deduced::_RawType>::value, "");
+ return __tuple_convertible<_QualType, tuple>::value;
}
template <class _Tuple>
static constexpr bool __enable_explicit() {
- return __tuple_constructible<_Tuple, tuple>::value
- && !__tuple_convertible<_Tuple, tuple>::value;
+ using _Deduced = __deduce_tuple_like<_Tuple>;
+ using _QualType = typename _Deduced::_QualType;
+ static_assert(__tuple_like<typename _Deduced::_RawType>::value, "");
+ return __tuple_constructible<_QualType, tuple>::value
+ && !__tuple_convertible<_QualType, tuple>::value;
}
};
@@ -814,53 +820,61 @@
_VSTD::forward<_Up>(__u)...) {}
template <class _Tuple,
+ class _Deduced = __deduce_tuple_like<_Tuple>,
+ class _TupBase = typename _Deduced::_QualType,
typename enable_if
<
_CheckTupleLikeConstructor<
- __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
- && !_PackExpandsToThisTuple<_Tuple>::value
- >::template __enable_implicit<_Tuple>(),
+ _Deduced::_Size == sizeof...(_Tp)
+ && !_PackExpandsToThisTuple<_TupBase>::value
+ >::template __enable_implicit<_TupBase>(),
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
- tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
- : base_(_VSTD::forward<_Tuple>(__t)) {}
+ tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _TupBase>::value))
+ : base_(_VSTD::forward<_TupBase>(__t)) {}
template <class _Tuple,
+ class _Deduced = __deduce_tuple_like<_Tuple>,
+ class _TupBase = typename _Deduced::_QualType,
typename enable_if
<
_CheckTupleLikeConstructor<
- __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
- && !_PackExpandsToThisTuple<_Tuple>::value
- >::template __enable_explicit<_Tuple>(),
+ _Deduced::_Size == sizeof...(_Tp)
+ && !_PackExpandsToThisTuple<_TupBase>::value
+ >::template __enable_explicit<_TupBase>(),
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
explicit
- tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _Tuple>::value))
- : base_(_VSTD::forward<_Tuple>(__t)) {}
+ tuple(_Tuple&& __t) _NOEXCEPT_((is_nothrow_constructible<base, _TupBase>::value))
+ : base_(_VSTD::forward<_TupBase>(__t)) {}
template <class _Alloc, class _Tuple,
+ class _Deduced = __deduce_tuple_like<_Tuple>,
+ class _TupBase = typename _Deduced::_QualType,
typename enable_if
<
_CheckTupleLikeConstructor<
- __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
- >::template __enable_implicit<_Tuple>(),
+ _Deduced::_Size == sizeof...(_Tp)
+ >::template __enable_implicit<_TupBase>(),
bool
>::type = false
>
_LIBCPP_INLINE_VISIBILITY
tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
- : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+ : base_(allocator_arg_t(), __a, _VSTD::forward<_TupBase>(__t)) {}
template <class _Alloc, class _Tuple,
+ class _Deduced = __deduce_tuple_like<_Tuple>,
+ class _TupBase = typename _Deduced::_QualType,
typename enable_if
<
_CheckTupleLikeConstructor<
- __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
- >::template __enable_explicit<_Tuple>(),
+ _Deduced::_Size == sizeof...(_Tp)
+ >::template __enable_explicit<_TupBase>(),
bool
>::type = false
>
@@ -873,7 +887,7 @@
using _CanMoveAssign = __all<is_move_assignable<_Tp>::value...>;
_LIBCPP_INLINE_VISIBILITY
- tuple& operator=(typename conditional<_CanCopyAssign::value, tuple, __nat>::type const& __t)
+ tuple& operator=(typename conditional<_CanCopyAssign::value, tuple const&, __nat>::type const& __t)
_NOEXCEPT_((__all<is_nothrow_copy_assignable<_Tp>::value...>::value))
{
base_.operator=(__t.base_);
@@ -889,16 +903,18 @@
}
template <class _Tuple,
+ class _Deducer = __deduce_tuple_like<_Tuple>,
+ class _QualTupleBase = typename _Deducer::_QualType,
class = typename enable_if
<
- __tuple_assignable<_Tuple, tuple>::value
+ __tuple_assignable<_QualTupleBase, tuple>::value
>::type
>
_LIBCPP_INLINE_VISIBILITY
tuple&
- operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _Tuple>::value))
+ operator=(_Tuple&& __t) _NOEXCEPT_((is_nothrow_assignable<base&, _QualTupleBase>::value))
{
- base_.operator=(_VSTD::forward<_Tuple>(__t));
+ base_.operator=(_VSTD::forward<_QualTupleBase>(__t));
return *this;
}
Index: include/__tuple
===================================================================
--- include/__tuple
+++ include/__tuple
@@ -453,19 +453,57 @@
#endif // _LIBCPP_HAS_NO_VARIADICS
#ifndef _LIBCPP_CXX03_LANG
-template <bool _IsTuple, class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp : false_type {};
-
-template <class _SizeTrait, size_t _Expected>
-struct __tuple_like_with_size_imp<true, _SizeTrait, _Expected>
- : integral_constant<bool, _SizeTrait::value == _Expected> {};
-
-template <class _Tuple, size_t _ExpectedSize,
- class _RawTuple = typename __uncvref<_Tuple>::type>
-using __tuple_like_with_size = __tuple_like_with_size_imp<
- __tuple_like<_RawTuple>::value,
- tuple_size<_RawTuple>, _ExpectedSize
- >;
+
+template <class _Tp, size_t _TSize, bool _Good = true>
+struct __lookup_result {
+ using type = _Tp;
+ static constexpr bool _Success = _Good;
+ static constexpr size_t _Size = _TSize;
+};
+using __lookup_failure = __lookup_result<void, (size_t)-1, false>;
+
+template <class ..._Args>
+auto __deduce_tuple_type_ovl(tuple<_Args...>&)
+ -> __lookup_result<tuple<_Args...>, sizeof...(_Args)>;
+
+template <class _T1, class _T2>
+auto __deduce_tuple_type_ovl(pair<_T1, _T2>&)
+ -> __lookup_result<pair<_T1, _T2>, 2>;
+
+template <class _Tp, size_t _Size>
+auto __deduce_tuple_type_ovl(array<_Tp, _Size>&)
+ -> __lookup_result<array<_Tp, _Size>, _Size>;
+
+template <class _Tp>
+auto __deduce_tuple_type_imp(int)
+ -> decltype(__deduce_tuple_type_ovl(_VSTD::declval<__uncvref_t<_Tp>&>()));
+template <class> __lookup_failure __deduce_tuple_type_imp(...);
+
+// __deduce_tuple_like - Given a type determine if it is, or is derived from
+// a tuple-like type. This trait is used to support constructing and assigning
+// to std::tuple from user-types derived from a tuple-like type.
+template <class _TupleLike,
+ class _Result = decltype(__deduce_tuple_type_imp<_TupleLike>(0)),
+ bool _Good = _Result::_Success>
+struct __deduce_tuple_like {
+ static_assert(_Good, "incorrect specialization choosen");
+ static constexpr bool _Success = true;
+ static constexpr size_t _Size = _Result::_Size;
+ using _RawType = typename _Result::type;
+ using _QualType =
+ typename __propagate_value_category<_TupleLike>::template __apply<_RawType>;
+};
+
+template <class _TupleLike, class _Result>
+struct __deduce_tuple_like<_TupleLike, _Result, /*_Good=*/false> {
+ static constexpr bool _Success = false;
+ static constexpr size_t _Size = (size_t)-1;
+};
+
+template <class _TupleLike, size_t _ExpectedSize,
+ class _Deduced = __deduce_tuple_like<_TupleLike>>
+using __tuple_like_with_size = integral_constant<bool,
+ _Deduced::_Success && _Deduced::_Size == _ExpectedSize>;
struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail {
template <class ...>
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
