Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
20 kB · 556 lines
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557// -*- C++ -*-//===----------------------------------------------------------------------===////// 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.////===----------------------------------------------------------------------===//#ifndef _LIBCPP___TUPLE#define _LIBCPP___TUPLE#include <__config>#include <cstddef>#include <type_traits>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_BEGIN_NAMESPACE_STDtemplate <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size;#if !defined(_LIBCPP_CXX03_LANG)template <class _Tp, class...>using __enable_if_tuple_size_imp = _Tp;template <class _Tp>class _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< const _Tp, typename enable_if<!is_volatile<_Tp>::value>::type, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> : public integral_constant<size_t, tuple_size<_Tp>::value> {};template <class _Tp>class _LIBCPP_TEMPLATE_VIS tuple_size<__enable_if_tuple_size_imp< volatile _Tp, typename enable_if<!is_const<_Tp>::value>::type, integral_constant<size_t, sizeof(tuple_size<_Tp>)>>> : public integral_constant<size_t, tuple_size<_Tp>::value> {};template <class _Tp>class _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> {};#elsetemplate <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<const _Tp> : public tuple_size<_Tp> {};template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<volatile _Tp> : public tuple_size<_Tp> {};template <class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};#endiftemplate <size_t _Ip, class _Tp> class _LIBCPP_TEMPLATE_VIS tuple_element;template <size_t _Ip, class _Tp>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const _Tp>{public: typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;};template <size_t _Ip, class _Tp>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, volatile _Tp>{public: typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;};template <size_t _Ip, class _Tp>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, const volatile _Tp>{public: typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;};template <class _Tp> struct __tuple_like : false_type {};template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};// tuple specializations#ifndef _LIBCPP_CXX03_LANGtemplate <size_t...> struct __tuple_indices {};template <class _IdxType, _IdxType... _Values>struct __integer_sequence { template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType> using __convert = _ToIndexSeq<_ToIndexType, _Values...>; template <size_t _Sp> using __to_tuple_indices = __tuple_indices<(_Values + _Sp)...>;};#if !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)namespace __detail {template<typename _Tp, size_t ..._Extra> struct __repeat;template<typename _Tp, _Tp ..._Np, size_t ..._Extra> struct __repeat<__integer_sequence<_Tp, _Np...>, _Extra...> { typedef __integer_sequence<_Tp, _Np..., sizeof...(_Np) + _Np..., 2 * sizeof...(_Np) + _Np..., 3 * sizeof...(_Np) + _Np..., 4 * sizeof...(_Np) + _Np..., 5 * sizeof...(_Np) + _Np..., 6 * sizeof...(_Np) + _Np..., 7 * sizeof...(_Np) + _Np..., _Extra...> type;};template<size_t _Np> struct __parity;template<size_t _Np> struct __make : __parity<_Np % 8>::template __pmake<_Np> {};template<> struct __make<0> { typedef __integer_sequence<size_t> type; };template<> struct __make<1> { typedef __integer_sequence<size_t, 0> type; };template<> struct __make<2> { typedef __integer_sequence<size_t, 0, 1> type; };template<> struct __make<3> { typedef __integer_sequence<size_t, 0, 1, 2> type; };template<> struct __make<4> { typedef __integer_sequence<size_t, 0, 1, 2, 3> type; };template<> struct __make<5> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4> type; };template<> struct __make<6> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5> type; };template<> struct __make<7> { typedef __integer_sequence<size_t, 0, 1, 2, 3, 4, 5, 6> type; };template<> struct __parity<0> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type> {}; };template<> struct __parity<1> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 1> {}; };template<> struct __parity<2> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 2, _Np - 1> {}; };template<> struct __parity<3> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 3, _Np - 2, _Np - 1> {}; };template<> struct __parity<4> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };template<> struct __parity<5> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };template<> struct __parity<6> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };template<> struct __parity<7> { template<size_t _Np> struct __pmake : __repeat<typename __make<_Np / 8>::type, _Np - 7, _Np - 6, _Np - 5, _Np - 4, _Np - 3, _Np - 2, _Np - 1> {}; };} // namespace detail#endif // !__has_builtin(__make_integer_seq) || defined(_LIBCPP_TESTING_FALLBACK_MAKE_INTEGER_SEQUENCE)#if __has_builtin(__make_integer_seq)template <size_t _Ep, size_t _Sp>using __make_indices_imp = typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template __to_tuple_indices<_Sp>;#elsetemplate <size_t _Ep, size_t _Sp>using __make_indices_imp = typename __detail::__make<_Ep - _Sp>::type::template __to_tuple_indices<_Sp>;#endiftemplate <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;};template <class ..._Tp> class _LIBCPP_TEMPLATE_VIS tuple;template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};template <class ..._Tp>class _LIBCPP_TEMPLATE_VIS tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)>{};template <size_t _Ip, class ..._Tp>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, tuple<_Tp...> >::type&get(tuple<_Tp...>&) _NOEXCEPT;template <size_t _Ip, class ..._Tp>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, tuple<_Tp...> >::type&get(const tuple<_Tp...>&) _NOEXCEPT;template <size_t _Ip, class ..._Tp>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, tuple<_Tp...> >::type&&get(tuple<_Tp...>&&) _NOEXCEPT;template <size_t _Ip, class ..._Tp>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, tuple<_Tp...> >::type&&get(const tuple<_Tp...>&&) _NOEXCEPT;#endif // !defined(_LIBCPP_CXX03_LANG)// pair specializationstemplate <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};template <size_t _Ip, class _T1, class _T2>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, pair<_T1, _T2> >::type&get(pair<_T1, _T2>&) _NOEXCEPT;template <size_t _Ip, class _T1, class _T2>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, pair<_T1, _T2> >::type&get(const pair<_T1, _T2>&) _NOEXCEPT;#ifndef _LIBCPP_CXX03_LANGtemplate <size_t _Ip, class _T1, class _T2>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11typename tuple_element<_Ip, pair<_T1, _T2> >::type&&get(pair<_T1, _T2>&&) _NOEXCEPT;template <size_t _Ip, class _T1, class _T2>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&get(const pair<_T1, _T2>&&) _NOEXCEPT;#endif// array specializationstemplate <class _Tp, size_t _Size> struct _LIBCPP_TEMPLATE_VIS array;template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};template <size_t _Ip, class _Tp, size_t _Size>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11_Tp&get(array<_Tp, _Size>&) _NOEXCEPT;template <size_t _Ip, class _Tp, size_t _Size>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const _Tp&get(const array<_Tp, _Size>&) _NOEXCEPT;#ifndef _LIBCPP_CXX03_LANGtemplate <size_t _Ip, class _Tp, size_t _Size>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11_Tp&&get(array<_Tp, _Size>&&) _NOEXCEPT;template <size_t _Ip, class _Tp, size_t _Size>_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11const _Tp&&get(const array<_Tp, _Size>&&) _NOEXCEPT;#endif#ifndef _LIBCPP_CXX03_LANG// __tuple_typestemplate <class ..._Tp> struct __tuple_types {};#if !__has_builtin(__type_pack_element)namespace __indexer_detail {template <size_t _Idx, class _Tp>struct __indexed { using type = _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_detailtemplate <size_t _Idx, class ..._Types>using __type_pack_element = typename decltype( __indexer_detail::__at_index<_Idx>( __indexer_detail::__indexer< __tuple_types<_Types...>, typename __make_tuple_indices<sizeof...(_Types)>::type >{}) )::type;#endiftemplate <size_t _Ip, class ..._Types>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, __tuple_types<_Types...>>{public: static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range"); typedef __type_pack_element<_Ip, _Types...> type;};template <class ..._Tp>class _LIBCPP_TEMPLATE_VIS tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)>{};template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};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 = const _Tp;};template <>struct __apply_cv_mf<false, false, true> { template <class _Tp> using __apply = volatile _Tp;};template <>struct __apply_cv_mf<false, true, true> { template <class _Tp> using __apply = const volatile _Tp;};template <>struct __apply_cv_mf<true, false, false> { template <class _Tp> using __apply = _Tp&;};template <>struct __apply_cv_mf<true, true, false> { template <class _Tp> using __apply = const _Tp&;};template <>struct __apply_cv_mf<true, false, true> { template <class _Tp> using __apply = volatile _Tp&;};template <>struct __apply_cv_mf<true, true, true> { template <class _Tp> using __apply = const volatile _Tp&;};template <class _Tp, class _RawTp = typename remove_reference<_Tp>::type>using __apply_cv_t = __apply_cv_mf< is_lvalue_reference<_Tp>::value, is_const<_RawTp>::value, is_volatile<_RawTp>::value>;// __make_tuple_types// __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 = __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<typename remove_reference<_Tp>::type>::value, size_t _Sp = 0, bool _SameSize = (_Ep == tuple_size<typename remove_reference<_Tp>::type>::value)>struct __make_tuple_types{ static_assert(_Sp <= _Ep, "__make_tuple_types input error"); using _RawTp = typename remove_cv<typename remove_reference<_Tp>::type>::type; 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 __tuple_types<_Types...> type;};template <class ..._Types, size_t _Ep>struct __make_tuple_types<__tuple_types<_Types...>, _Ep, 0, true> { typedef __tuple_types<_Types...> type;};template <bool ..._Preds>struct __all_dummy;template <bool ..._Pred>using __all = is_same<__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<typename enable_if<_Trait<_LArgs, _RArgs>::value, bool>::type{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_convertibletemplate <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, bool = __tuple_like<_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_constructibletemplate <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_sfinae_base::__constructible< typename __make_tuple_types<_Tp>::type , typename __make_tuple_types<_Up>::type >{};// __tuple_assignabletemplate <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value, bool = __tuple_like<_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>class _LIBCPP_TEMPLATE_VIS tuple_element<_Ip, tuple<_Tp...> >{public: typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;};#if _LIBCPP_STD_VER > 11template <size_t _Ip, class ..._Tp>using tuple_element_t = typename tuple_element <_Ip, _Tp...>::type;#endiftemplate <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 >;struct _LIBCPP_TYPE_VIS __check_tuple_constructor_fail { template <class ...> static constexpr bool __enable_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 > 14template <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