// -*- C++ -*- //===----------------------------------------------------------------------===// // // 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___FUNCTIONAL_BIND_H #define _LIBCPP___FUNCTIONAL_BIND_H #include <__config> #include <__functional/weak_result_type.h> #include <__functional/invoke.h> #include <cstddef> #include <tuple> #include <type_traits> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #pragma GCC system_header #endif _LIBCPP_BEGIN_NAMESPACE_STD template<class _Tp> struct __is_bind_expression : public false_type {}; template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 template <class _Tp> inline constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value; #endif template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {}; template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder : public __is_placeholder<typename remove_cv<_Tp>::type> {}; #if _LIBCPP_STD_VER > 14 template <class _Tp> inline constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value; #endif namespace placeholders { template <int _Np> struct __ph {}; #if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY) _LIBCPP_FUNC_VIS extern const __ph<1> _1; _LIBCPP_FUNC_VIS extern const __ph<2> _2; _LIBCPP_FUNC_VIS extern const __ph<3> _3; _LIBCPP_FUNC_VIS extern const __ph<4> _4; _LIBCPP_FUNC_VIS extern const __ph<5> _5; _LIBCPP_FUNC_VIS extern const __ph<6> _6; _LIBCPP_FUNC_VIS extern const __ph<7> _7; _LIBCPP_FUNC_VIS extern const __ph<8> _8; _LIBCPP_FUNC_VIS extern const __ph<9> _9; _LIBCPP_FUNC_VIS extern const __ph<10> _10; #else /* inline */ constexpr __ph<1> _1{}; /* inline */ constexpr __ph<2> _2{}; /* inline */ constexpr __ph<3> _3{}; /* inline */ constexpr __ph<4> _4{}; /* inline */ constexpr __ph<5> _5{}; /* inline */ constexpr __ph<6> _6{}; /* inline */ constexpr __ph<7> _7{}; /* inline */ constexpr __ph<8> _8{}; /* inline */ constexpr __ph<9> _9{}; /* inline */ constexpr __ph<10> _10{}; #endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_LIBRARY) } // placeholders template<int _Np> struct __is_placeholder<placeholders::__ph<_Np> > : public integral_constant<int, _Np> {}; #ifndef _LIBCPP_CXX03_LANG template <class _Tp, class _Uj> inline _LIBCPP_INLINE_VISIBILITY _Tp& __mu(reference_wrapper<_Tp> __t, _Uj&) { return __t.get(); } template <class _Ti, class ..._Uj, size_t ..._Indx> inline _LIBCPP_INLINE_VISIBILITY typename __invoke_of<_Ti&, _Uj...>::type __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) { return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...); } template <class _Ti, class ..._Uj> inline _LIBCPP_INLINE_VISIBILITY typename __enable_if_t < is_bind_expression<_Ti>::value, __invoke_of<_Ti&, _Uj...> >::type __mu(_Ti& __ti, tuple<_Uj...>& __uj) { typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices; return _VSTD::__mu_expand(__ti, __uj, __indices()); } template <bool IsPh, class _Ti, class _Uj> struct __mu_return2 {}; template <class _Ti, class _Uj> struct __mu_return2<true, _Ti, _Uj> { typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type; }; template <class _Ti, class _Uj> inline _LIBCPP_INLINE_VISIBILITY typename enable_if < 0 < is_placeholder<_Ti>::value, typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type >::type __mu(_Ti&, _Uj& __uj) { const size_t _Indx = is_placeholder<_Ti>::value - 1; return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj)); } template <class _Ti, class _Uj> inline _LIBCPP_INLINE_VISIBILITY typename enable_if < !is_bind_expression<_Ti>::value && is_placeholder<_Ti>::value == 0 && !__is_reference_wrapper<_Ti>::value, _Ti& >::type __mu(_Ti& __ti, _Uj&) { return __ti; } template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh, class _TupleUj> struct __mu_return_impl; template <bool _Invokable, class _Ti, class ..._Uj> struct __mu_return_invokable // false { typedef __nat type; }; template <class _Ti, class ..._Uj> struct __mu_return_invokable<true, _Ti, _Uj...> { typedef typename __invoke_of<_Ti&, _Uj...>::type type; }; template <class _Ti, class ..._Uj> struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> > : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...> { }; template <class _Ti, class _TupleUj> struct __mu_return_impl<_Ti, false, false, true, _TupleUj> { typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _TupleUj>::type&& type; }; template <class _Ti, class _TupleUj> struct __mu_return_impl<_Ti, true, false, false, _TupleUj> { typedef typename _Ti::type& type; }; template <class _Ti, class _TupleUj> struct __mu_return_impl<_Ti, false, false, false, _TupleUj> { typedef _Ti& type; }; #ifdef _LIBCPP_COMPILER_MSVC #pragma warning ( push ) #pragma warning ( disable : 4296 ) #endif template <class _Ti, class _TupleUj> struct __mu_return : public __mu_return_impl<_Ti, __is_reference_wrapper<_Ti>::value, is_bind_expression<_Ti>::value, 0 < is_placeholder<_Ti>::value && is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value, _TupleUj> { }; #ifdef _LIBCPP_COMPILER_MSVC #pragma warning ( pop ) #endif template <class _Fp, class _BoundArgs, class _TupleUj> struct __is_valid_bind_return { static const bool value = false; }; template <class _Fp, class ..._BoundArgs, class _TupleUj> struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return<_BoundArgs, _TupleUj>::type...>::value; }; template <class _Fp, class ..._BoundArgs, class _TupleUj> struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> { static const bool value = __invokable<_Fp, typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value; }; template <class _Fp, class _BoundArgs, class _TupleUj, bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value> struct __bind_return; template <class _Fp, class ..._BoundArgs, class _TupleUj> struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < _Fp&, typename __mu_return < _BoundArgs, _TupleUj >::type... >::type type; }; template <class _Fp, class ..._BoundArgs, class _TupleUj> struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> { typedef typename __invoke_of < _Fp&, typename __mu_return < const _BoundArgs, _TupleUj >::type... >::type type; }; template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> inline _LIBCPP_INLINE_VISIBILITY typename __bind_return<_Fp, _BoundArgs, _Args>::type __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) { return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...); } #ifdef _LIBCPP_COMPILER_MSVC #pragma warning ( push ) #pragma warning ( disable : 4296 ) #endif template<class _Fp, class ..._BoundArgs> class __bind #if _LIBCPP_STD_VER <= 17 || !defined(_LIBCPP_ABI_NO_BINDER_BASES) : public __weak_result_type<typename decay<_Fp>::type> #endif { protected: typedef typename decay<_Fp>::type _Fd; typedef tuple<typename decay<_BoundArgs>::type...> _Td; private: _Fd __f_; _Td __bound_args_; typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices; public: template <class _Gp, class ..._BA, class = typename enable_if < is_constructible<_Fd, _Gp>::value && !is_same<typename remove_reference<_Gp>::type, __bind>::value >::type> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit __bind(_Gp&& __f, _BA&& ...__bound_args) : __f_(_VSTD::forward<_Gp>(__f)), __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} template <class ..._Args> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type operator()(_Args&& ...__args) { return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); } template <class ..._Args> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type operator()(_Args&& ...__args) const { return _VSTD::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...)); } }; #ifdef _LIBCPP_COMPILER_MSVC #pragma warning ( pop ) #endif #if defined(__CUDACC__) && defined(_MSC_VER) # define Y_CUDAFE_MSVC_BUG #endif template<class _Fp, class ..._BoundArgs> struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; template<class _Rp, class _Fp, class ..._BoundArgs> class __bind_r : public __bind<_Fp, _BoundArgs...> { typedef __bind<_Fp, _BoundArgs...> base; typedef typename base::_Fd _Fd; #if !defined(Y_CUDAFE_MSVC_BUG) typedef typename base::_Td _Td; #else typedef typename tuple<typename decay<_BoundArgs>::type...> _Td; #endif public: typedef _Rp result_type; template <class _Gp, class ..._BA, class = typename enable_if < is_constructible<_Fd, _Gp>::value && !is_same<typename remove_reference<_Gp>::type, __bind_r>::value >::type> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) : base(_VSTD::forward<_Gp>(__f), _VSTD::forward<_BA>(__bound_args)...) {} template <class ..._Args> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if < is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type, result_type>::value || is_void<_Rp>::value, result_type >::type operator()(_Args&& ...__args) { typedef __invoke_void_return_wrapper<_Rp> _Invoker; return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...); } template <class ..._Args> _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 typename enable_if < is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type, result_type>::value || is_void<_Rp>::value, result_type >::type operator()(_Args&& ...__args) const { typedef __invoke_void_return_wrapper<_Rp> _Invoker; return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...); } }; template<class _Rp, class _Fp, class ..._BoundArgs> struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {}; template<class _Fp, class ..._BoundArgs> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bind<_Fp, _BoundArgs...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind<_Fp, _BoundArgs...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } template<class _Rp, class _Fp, class ..._BoundArgs> inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 __bind_r<_Rp, _Fp, _BoundArgs...> bind(_Fp&& __f, _BoundArgs&&... __bound_args) { typedef __bind_r<_Rp, _Fp, _BoundArgs...> type; return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...); } #endif // _LIBCPP_CXX03_LANG _LIBCPP_END_NAMESPACE_STD #endif // _LIBCPP___FUNCTIONAL_BIND_H