diff options
Diffstat (limited to 'libcxx/include/__tuple_dir')
| -rw-r--r-- | libcxx/include/__tuple_dir/apply_cv.h | 70 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/make_tuple_types.h | 84 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/pair_like.h | 32 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/sfinae_helpers.h | 196 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_element.h | 93 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_indices.h | 37 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_like.h | 51 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_like_ext.h | 44 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_size.h | 75 | ||||
| -rw-r--r-- | libcxx/include/__tuple_dir/tuple_types.h | 24 |
10 files changed, 706 insertions, 0 deletions
diff --git a/libcxx/include/__tuple_dir/apply_cv.h b/libcxx/include/__tuple_dir/apply_cv.h new file mode 100644 index 000000000000..296755a1d52d --- /dev/null +++ b/libcxx/include/__tuple_dir/apply_cv.h @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_APPLY_CV_H +#define _LIBCPP___TUPLE_APPLY_CV_H + +#include <__config> +#include <__type_traits/is_const.h> +#include <__type_traits/is_reference.h> +#include <__type_traits/is_volatile.h> +#include <__type_traits/remove_reference.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +#ifndef _LIBCPP_CXX03_LANG + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <bool _ApplyLV, bool _ApplyConst, bool _ApplyVolatile> +struct __apply_cv_mf; +template <> +struct __apply_cv_mf<false, false, false> { + template <class _Tp> using __apply = _Tp; +}; +template <> +struct __apply_cv_mf<false, true, false> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = const _Tp; +}; +template <> +struct __apply_cv_mf<false, false, true> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp; +}; +template <> +struct __apply_cv_mf<false, true, true> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp; +}; +template <> +struct __apply_cv_mf<true, false, false> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = _Tp&; +}; +template <> +struct __apply_cv_mf<true, true, false> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = const _Tp&; +}; +template <> +struct __apply_cv_mf<true, false, true> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = volatile _Tp&; +}; +template <> +struct __apply_cv_mf<true, true, true> { + template <class _Tp> using __apply _LIBCPP_NODEBUG = const volatile _Tp&; +}; +template <class _Tp, class _RawTp = __libcpp_remove_reference_t<_Tp> > +using __apply_cv_t _LIBCPP_NODEBUG = __apply_cv_mf< + is_lvalue_reference<_Tp>::value, + is_const<_RawTp>::value, + is_volatile<_RawTp>::value>; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_CXX03_LANG + +#endif // _LIBCPP___TUPLE_APPLY_CV_H diff --git a/libcxx/include/__tuple_dir/make_tuple_types.h b/libcxx/include/__tuple_dir/make_tuple_types.h new file mode 100644 index 000000000000..913ff9bbd60c --- /dev/null +++ b/libcxx/include/__tuple_dir/make_tuple_types.h @@ -0,0 +1,84 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_MAKE_TUPLE_TYPES_H +#define _LIBCPP___TUPLE_MAKE_TUPLE_TYPES_H + +#include <__config> +#include <__fwd/array.h> +#include <__fwd/tuple.h> +#include <__tuple_dir/apply_cv.h> +#include <__tuple_dir/tuple_element.h> +#include <__tuple_dir/tuple_indices.h> +#include <__tuple_dir/tuple_size.h> +#include <__tuple_dir/tuple_types.h> +#include <__type_traits/remove_cv.h> +#include <__type_traits/remove_reference.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +#ifndef _LIBCPP_CXX03_LANG + +_LIBCPP_BEGIN_NAMESPACE_STD + +// __make_tuple_types<_Tuple<_Types...>, _Ep, _Sp>::type is a +// __tuple_types<_Types...> using only those _Types in the range [_Sp, _Ep). +// _Sp defaults to 0 and _Ep defaults to tuple_size<_Tuple>. If _Tuple is a +// lvalue_reference type, then __tuple_types<_Types&...> is the result. + +template <class _TupleTypes, class _TupleIndices> +struct __make_tuple_types_flat; + +template <template <class...> class _Tuple, class ..._Types, size_t ..._Idx> +struct __make_tuple_types_flat<_Tuple<_Types...>, __tuple_indices<_Idx...>> { + // Specialization for pair, tuple, and __tuple_types + template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>> + using __apply_quals _LIBCPP_NODEBUG = __tuple_types< + typename _ApplyFn::template __apply<__type_pack_element<_Idx, _Types...>>... + >; +}; + +template <class _Vt, size_t _Np, size_t ..._Idx> +struct __make_tuple_types_flat<array<_Vt, _Np>, __tuple_indices<_Idx...>> { + template <size_t> + using __value_type = _Vt; + template <class _Tp, class _ApplyFn = __apply_cv_t<_Tp>> + using __apply_quals = __tuple_types< + typename _ApplyFn::template __apply<__value_type<_Idx>>... + >; +}; + +template <class _Tp, size_t _Ep = tuple_size<__libcpp_remove_reference_t<_Tp> >::value, + size_t _Sp = 0, + bool _SameSize = (_Ep == tuple_size<__libcpp_remove_reference_t<_Tp> >::value)> +struct __make_tuple_types +{ + static_assert(_Sp <= _Ep, "__make_tuple_types input error"); + using _RawTp = __remove_cv_t<__libcpp_remove_reference_t<_Tp> >; + using _Maker = __make_tuple_types_flat<_RawTp, typename __make_tuple_indices<_Ep, _Sp>::type>; + using type = typename _Maker::template __apply_quals<_Tp>; +}; + +template <class ..._Types, size_t _Ep> +struct __make_tuple_types<tuple<_Types...>, _Ep, 0, true> { + typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type; +}; + +template <class ..._Types, size_t _Ep> +struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> { + typedef _LIBCPP_NODEBUG __tuple_types<_Types...> type; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_CXX03_LANG + +#endif // _LIBCPP___TUPLE_MAKE_TUPLE_TYPES_H diff --git a/libcxx/include/__tuple_dir/pair_like.h b/libcxx/include/__tuple_dir/pair_like.h new file mode 100644 index 000000000000..87407ad95b6f --- /dev/null +++ b/libcxx/include/__tuple_dir/pair_like.h @@ -0,0 +1,32 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_PAIR_LIKE_H +#define _LIBCPP___TUPLE_PAIR_LIKE_H + +#include <__config> +#include <__tuple_dir/tuple_like.h> +#include <__tuple_dir/tuple_size.h> +#include <__type_traits/remove_cvref.h> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 20 + +template <class _Tp> +concept __pair_like = __tuple_like<_Tp> && tuple_size<remove_cvref_t<_Tp>>::value == 2; + +#endif // _LIBCPP_STD_VER >= 20 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_PAIR_LIKE_H diff --git a/libcxx/include/__tuple_dir/sfinae_helpers.h b/libcxx/include/__tuple_dir/sfinae_helpers.h new file mode 100644 index 000000000000..fcd65a0817be --- /dev/null +++ b/libcxx/include/__tuple_dir/sfinae_helpers.h @@ -0,0 +1,196 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_SFINAE_HELPERS_H +#define _LIBCPP___TUPLE_SFINAE_HELPERS_H + +#include <__config> +#include <__fwd/tuple.h> +#include <__tuple_dir/make_tuple_types.h> +#include <__tuple_dir/tuple_element.h> +#include <__tuple_dir/tuple_like_ext.h> +#include <__tuple_dir/tuple_size.h> +#include <__tuple_dir/tuple_types.h> +#include <__type_traits/enable_if.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/is_assignable.h> +#include <__type_traits/is_constructible.h> +#include <__type_traits/is_convertible.h> +#include <__type_traits/is_same.h> +#include <__type_traits/remove_cvref.h> +#include <__type_traits/remove_reference.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#ifndef _LIBCPP_CXX03_LANG + +template <bool ..._Preds> +struct __all_dummy; + +template <bool ..._Pred> +struct __all : _IsSame<__all_dummy<_Pred...>, __all_dummy<((void)_Pred, true)...>> {}; + +struct __tuple_sfinae_base { + template <template <class, class...> class _Trait, + class ..._LArgs, class ..._RArgs> + static auto __do_test(__tuple_types<_LArgs...>, __tuple_types<_RArgs...>) + -> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>; + template <template <class...> class> + static auto __do_test(...) -> false_type; + + template <class _FromArgs, class _ToArgs> + using __constructible = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{})); + template <class _FromArgs, class _ToArgs> + using __convertible = decltype(__do_test<is_convertible>(_FromArgs{}, _ToArgs{})); + template <class _FromArgs, class _ToArgs> + using __assignable = decltype(__do_test<is_assignable>(_ToArgs{}, _FromArgs{})); +}; + +// __tuple_convertible + +template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value, + bool = __tuple_like_ext<_Up>::value> +struct __tuple_convertible + : public false_type {}; + +template <class _Tp, class _Up> +struct __tuple_convertible<_Tp, _Up, true, true> + : public __tuple_sfinae_base::__convertible< + typename __make_tuple_types<_Tp>::type + , typename __make_tuple_types<_Up>::type + > +{}; + +// __tuple_constructible + +template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value, + bool = __tuple_like_ext<_Up>::value> +struct __tuple_constructible + : public false_type {}; + +template <class _Tp, class _Up> +struct __tuple_constructible<_Tp, _Up, true, true> + : public __tuple_sfinae_base::__constructible< + typename __make_tuple_types<_Tp>::type + , typename __make_tuple_types<_Up>::type + > +{}; + +// __tuple_assignable + +template <class _Tp, class _Up, bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value, + bool = __tuple_like_ext<_Up>::value> +struct __tuple_assignable + : public false_type {}; + +template <class _Tp, class _Up> +struct __tuple_assignable<_Tp, _Up, true, true> + : public __tuple_sfinae_base::__assignable< + typename __make_tuple_types<_Tp>::type + , typename __make_tuple_types<_Up&>::type + > +{}; + + +template <size_t _Ip, class ..._Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> > +{ + typedef _LIBCPP_NODEBUG typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type; +}; + +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 = __libcpp_remove_reference_t<_Tuple> > +using __tuple_like_with_size _LIBCPP_NODEBUG = __tuple_like_with_size_imp< + __tuple_like_ext<_RawTuple>::value, + tuple_size<_RawTuple>, _ExpectedSize + >; + +struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail { + + static constexpr bool __enable_explicit_default() { return false; } + static constexpr bool __enable_implicit_default() { return false; } + template <class ...> + static constexpr bool __enable_explicit() { return false; } + template <class ...> + static constexpr bool __enable_implicit() { return false; } + template <class ...> + static constexpr bool __enable_assign() { return false; } +}; +#endif // !defined(_LIBCPP_CXX03_LANG) + +#if _LIBCPP_STD_VER > 14 + +template <bool _CanCopy, bool _CanMove> +struct __sfinae_ctor_base {}; +template <> +struct __sfinae_ctor_base<false, false> { + __sfinae_ctor_base() = default; + __sfinae_ctor_base(__sfinae_ctor_base const&) = delete; + __sfinae_ctor_base(__sfinae_ctor_base &&) = delete; + __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default; + __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default; +}; +template <> +struct __sfinae_ctor_base<true, false> { + __sfinae_ctor_base() = default; + __sfinae_ctor_base(__sfinae_ctor_base const&) = default; + __sfinae_ctor_base(__sfinae_ctor_base &&) = delete; + __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default; + __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default; +}; +template <> +struct __sfinae_ctor_base<false, true> { + __sfinae_ctor_base() = default; + __sfinae_ctor_base(__sfinae_ctor_base const&) = delete; + __sfinae_ctor_base(__sfinae_ctor_base &&) = default; + __sfinae_ctor_base& operator=(__sfinae_ctor_base const&) = default; + __sfinae_ctor_base& operator=(__sfinae_ctor_base&&) = default; +}; + +template <bool _CanCopy, bool _CanMove> +struct __sfinae_assign_base {}; +template <> +struct __sfinae_assign_base<false, false> { + __sfinae_assign_base() = default; + __sfinae_assign_base(__sfinae_assign_base const&) = default; + __sfinae_assign_base(__sfinae_assign_base &&) = default; + __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete; + __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete; +}; +template <> +struct __sfinae_assign_base<true, false> { + __sfinae_assign_base() = default; + __sfinae_assign_base(__sfinae_assign_base const&) = default; + __sfinae_assign_base(__sfinae_assign_base &&) = default; + __sfinae_assign_base& operator=(__sfinae_assign_base const&) = default; + __sfinae_assign_base& operator=(__sfinae_assign_base&&) = delete; +}; +template <> +struct __sfinae_assign_base<false, true> { + __sfinae_assign_base() = default; + __sfinae_assign_base(__sfinae_assign_base const&) = default; + __sfinae_assign_base(__sfinae_assign_base &&) = default; + __sfinae_assign_base& operator=(__sfinae_assign_base const&) = delete; + __sfinae_assign_base& operator=(__sfinae_assign_base&&) = default; +}; +#endif // _LIBCPP_STD_VER > 14 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_SFINAE_HELPERS_H diff --git a/libcxx/include/__tuple_dir/tuple_element.h b/libcxx/include/__tuple_dir/tuple_element.h new file mode 100644 index 000000000000..06f49bf500fb --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_element.h @@ -0,0 +1,93 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_TUPLE_ELEMENT_H +#define _LIBCPP___TUPLE_TUPLE_ELEMENT_H + +#include <__config> +#include <__tuple_dir/tuple_indices.h> +#include <__tuple_dir/tuple_types.h> +#include <__type_traits/add_const.h> +#include <__type_traits/add_cv.h> +#include <__type_traits/add_volatile.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <size_t _Ip, class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_element; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp> +{ + typedef _LIBCPP_NODEBUG typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type; +}; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp> +{ + typedef _LIBCPP_NODEBUG typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type; +}; + +template <size_t _Ip, class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp> +{ + typedef _LIBCPP_NODEBUG typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type; +}; + +#ifndef _LIBCPP_CXX03_LANG + +#if !__has_builtin(__type_pack_element) + +namespace __indexer_detail { + +template <size_t _Idx, class _Tp> +struct __indexed { using type _LIBCPP_NODEBUG = _Tp; }; + +template <class _Types, class _Indexes> struct __indexer; + +template <class ..._Types, size_t ..._Idx> +struct __indexer<__tuple_types<_Types...>, __tuple_indices<_Idx...>> + : __indexed<_Idx, _Types>... +{}; + +template <size_t _Idx, class _Tp> +__indexed<_Idx, _Tp> __at_index(__indexed<_Idx, _Tp> const&); + +} // namespace __indexer_detail + +template <size_t _Idx, class ..._Types> +using __type_pack_element _LIBCPP_NODEBUG = typename decltype( + __indexer_detail::__at_index<_Idx>( + __indexer_detail::__indexer< + __tuple_types<_Types...>, + typename __make_tuple_indices<sizeof...(_Types)>::type + >{}) + )::type; +#endif + +template <size_t _Ip, class ..._Types> +struct _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...> > +{ + static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); + typedef _LIBCPP_NODEBUG __type_pack_element<_Ip, _Types...> type; +}; + +#if _LIBCPP_STD_VER > 11 +template <size_t _Ip, class ..._Tp> +using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element <_Ip, _Tp...>::type; +#endif + +#endif // _LIBCPP_CXX03_LANG + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H diff --git a/libcxx/include/__tuple_dir/tuple_indices.h b/libcxx/include/__tuple_dir/tuple_indices.h new file mode 100644 index 000000000000..18666d5948c9 --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_indices.h @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_MAKE_TUPLE_INDICES_H +#define _LIBCPP___TUPLE_MAKE_TUPLE_INDICES_H + +#include <__config> +#include <__utility/integer_sequence.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +#ifndef _LIBCPP_CXX03_LANG + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <size_t...> struct __tuple_indices {}; + +template <size_t _Ep, size_t _Sp = 0> +struct __make_tuple_indices +{ + static_assert(_Sp <= _Ep, "__make_tuple_indices input error"); + typedef __make_indices_imp<_Ep, _Sp> type; +}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_CXX03_LANG + +#endif // _LIBCPP___TUPLE_MAKE_TUPLE_INDICES_H diff --git a/libcxx/include/__tuple_dir/tuple_like.h b/libcxx/include/__tuple_dir/tuple_like.h new file mode 100644 index 000000000000..dab395be616b --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_like.h @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_TUPLE_LIKE_H +#define _LIBCPP___TUPLE_TUPLE_LIKE_H + +#include <__config> +#include <__fwd/array.h> +#include <__fwd/pair.h> +#include <__fwd/subrange.h> +#include <__fwd/tuple.h> +#include <__type_traits/integral_constant.h> +#include <__type_traits/remove_cvref.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +#if _LIBCPP_STD_VER >= 20 + +template <class _Tp> +struct __tuple_like_impl : false_type {}; + +template <class... _Tp> +struct __tuple_like_impl<tuple<_Tp...> > : true_type {}; + +template <class _T1, class _T2> +struct __tuple_like_impl<pair<_T1, _T2> > : true_type {}; + +template <class _Tp, size_t _Size> +struct __tuple_like_impl<array<_Tp, _Size> > : true_type {}; + +template <class _Ip, class _Sp, ranges::subrange_kind _Kp> +struct __tuple_like_impl<ranges::subrange<_Ip, _Sp, _Kp> > : true_type {}; + +template <class _Tp> +concept __tuple_like = __tuple_like_impl<remove_cvref_t<_Tp>>::value; + +#endif // _LIBCPP_STD_VER >= 20 + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_TUPLE_LIKE_H diff --git a/libcxx/include/__tuple_dir/tuple_like_ext.h b/libcxx/include/__tuple_dir/tuple_like_ext.h new file mode 100644 index 000000000000..bf9869611273 --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_like_ext.h @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H +#define _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H + +#include <__config> +#include <__fwd/array.h> +#include <__fwd/pair.h> +#include <__fwd/tuple.h> +#include <__tuple_dir/tuple_types.h> +#include <__type_traits/integral_constant.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> struct __tuple_like_ext : false_type {}; + +template <class _Tp> struct __tuple_like_ext<const _Tp> : public __tuple_like_ext<_Tp> {}; +template <class _Tp> struct __tuple_like_ext<volatile _Tp> : public __tuple_like_ext<_Tp> {}; +template <class _Tp> struct __tuple_like_ext<const volatile _Tp> : public __tuple_like_ext<_Tp> {}; + +#ifndef _LIBCPP_CXX03_LANG +template <class... _Tp> struct __tuple_like_ext<tuple<_Tp...> > : true_type {}; +#endif + +template <class _T1, class _T2> struct __tuple_like_ext<pair<_T1, _T2> > : true_type {}; + +template <class _Tp, size_t _Size> struct __tuple_like_ext<array<_Tp, _Size> > : true_type {}; + +template <class... _Tp> struct __tuple_like_ext<__tuple_types<_Tp...> > : true_type {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_TUPLE_LIKE_EXT_H diff --git a/libcxx/include/__tuple_dir/tuple_size.h b/libcxx/include/__tuple_dir/tuple_size.h new file mode 100644 index 000000000000..d551b2258cba --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_size.h @@ -0,0 +1,75 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_TUPLE_SIZE_H +#define _LIBCPP___TUPLE_TUPLE_SIZE_H + +#include <__config> +#include <__fwd/tuple.h> +#include <__tuple_dir/tuple_types.h> +#include <__type_traits/is_const.h> +#include <__type_traits/is_volatile.h> +#include <cstddef> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size; + +#if !defined(_LIBCPP_CXX03_LANG) +template <class _Tp, class...> +using __enable_if_tuple_size_imp = _Tp; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< + const _Tp, + __enable_if_t<!is_volatile<_Tp>::value>, + integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> + : public integral_constant<size_t, tuple_size<_Tp>::value> {}; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< + volatile _Tp, + __enable_if_t<!is_const<_Tp>::value>, + integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> + : public integral_constant<size_t, tuple_size<_Tp>::value> {}; + +template <class _Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< + const volatile _Tp, + integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> + : public integral_constant<size_t, tuple_size<_Tp>::value> {}; + +#else +template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {}; +template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {}; +template <class _Tp> struct _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {}; +#endif + +#ifndef _LIBCPP_CXX03_LANG + +template <class ..._Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > + : public integral_constant<size_t, sizeof...(_Tp)> +{ +}; + +template <class ..._Tp> +struct _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > + : public integral_constant<size_t, sizeof...(_Tp)> +{ +}; + +#endif // _LIBCPP_CXX03_LANG + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_TUPLE_SIZE_H diff --git a/libcxx/include/__tuple_dir/tuple_types.h b/libcxx/include/__tuple_dir/tuple_types.h new file mode 100644 index 000000000000..c5be81cce801 --- /dev/null +++ b/libcxx/include/__tuple_dir/tuple_types.h @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP___TUPLE_TUPLE_TYPES_H +#define _LIBCPP___TUPLE_TUPLE_TYPES_H + +#include <__config> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +# pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +template <class ..._Tp> struct __tuple_types {}; + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP___TUPLE_TUPLE_TYPES_H |