1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef _LIBCPP___FUNCTIONAL_BIND_H
11 #define _LIBCPP___FUNCTIONAL_BIND_H
12 
13 #include <__config>
14 #include <__functional/invoke.h>
15 #include <__functional/weak_result_type.h>
16 #include <__type_traits/decay.h>
17 #include <__type_traits/is_reference_wrapper.h>
18 #include <__type_traits/is_void.h>
19 #include <cstddef>
20 #include <tuple>
21 
22 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
23 #  pragma GCC system_header
24 #endif
25 
26 _LIBCPP_BEGIN_NAMESPACE_STD
27 
28 template<class _Tp>
29 struct is_bind_expression : _If<
30     _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
31     false_type,
32     is_bind_expression<__remove_cvref_t<_Tp> >
33 > {};
34 
35 #if _LIBCPP_STD_VER >= 17
36 template <class _Tp>
37 inline constexpr bool is_bind_expression_v = is_bind_expression<_Tp>::value;
38 #endif
39 
40 template<class _Tp>
41 struct is_placeholder : _If<
42     _IsSame<_Tp, __remove_cvref_t<_Tp> >::value,
43     integral_constant<int, 0>,
44     is_placeholder<__remove_cvref_t<_Tp> >
45 > {};
46 
47 #if _LIBCPP_STD_VER >= 17
48 template <class _Tp>
49 inline constexpr int is_placeholder_v = is_placeholder<_Tp>::value;
50 #endif
51 
52 namespace placeholders
53 {
54 
55 template <int _Np> struct __ph {};
56 
57 // C++17 recommends that we implement placeholders as `inline constexpr`, but allows
58 // implementing them as `extern <implementation-defined>`. Libc++ implements them as
59 // `extern const` in all standard modes to avoid an ABI break in C++03: making them
60 // `inline constexpr` requires removing their definition in the shared library to
61 // avoid ODR violations, which is an ABI break.
62 //
63 // In practice, since placeholders are empty, `extern const` is almost impossible
64 // to distinguish from `inline constexpr` from a usage stand point.
65 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<1>   _1;
66 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<2>   _2;
67 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<3>   _3;
68 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<4>   _4;
69 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<5>   _5;
70 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<6>   _6;
71 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<7>   _7;
72 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<8>   _8;
73 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<9>   _9;
74 _LIBCPP_EXPORTED_FROM_ABI extern const __ph<10> _10;
75 
76 } // namespace placeholders
77 
78 template<int _Np>
79 struct is_placeholder<placeholders::__ph<_Np> >
80     : public integral_constant<int, _Np> {};
81 
82 
83 #ifndef _LIBCPP_CXX03_LANG
84 
85 template <class _Tp, class _Uj>
86 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
87 _Tp&
88 __mu(reference_wrapper<_Tp> __t, _Uj&)
89 {
90     return __t.get();
91 }
92 
93 template <class _Ti, class ..._Uj, size_t ..._Indx>
94 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
95 typename __invoke_of<_Ti&, _Uj...>::type
96 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
97 {
98     return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
99 }
100 
101 template <class _Ti, class ..._Uj>
102 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
103 typename __enable_if_t
104 <
105     is_bind_expression<_Ti>::value,
106     __invoke_of<_Ti&, _Uj...>
107 >::type
108 __mu(_Ti& __ti, tuple<_Uj...>& __uj)
109 {
110     typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
111     return _VSTD::__mu_expand(__ti, __uj, __indices());
112 }
113 
114 template <bool IsPh, class _Ti, class _Uj>
115 struct __mu_return2 {};
116 
117 template <class _Ti, class _Uj>
118 struct __mu_return2<true, _Ti, _Uj>
119 {
120     typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
121 };
122 
123 template <class _Ti, class _Uj>
124 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
125 typename enable_if
126 <
127     0 < is_placeholder<_Ti>::value,
128     typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
129 >::type
130 __mu(_Ti&, _Uj& __uj)
131 {
132     const size_t __indx = is_placeholder<_Ti>::value - 1;
133     return _VSTD::forward<typename tuple_element<__indx, _Uj>::type>(_VSTD::get<__indx>(__uj));
134 }
135 
136 template <class _Ti, class _Uj>
137 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
138 typename enable_if
139 <
140     !is_bind_expression<_Ti>::value &&
141     is_placeholder<_Ti>::value == 0 &&
142     !__is_reference_wrapper<_Ti>::value,
143     _Ti&
144 >::type
145 __mu(_Ti& __ti, _Uj&)
146 {
147     return __ti;
148 }
149 
150 template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
151           class _TupleUj>
152 struct __mu_return_impl;
153 
154 template <bool _Invokable, class _Ti, class ..._Uj>
155 struct __mu_return_invokable  // false
156 {
157     typedef __nat type;
158 };
159 
160 template <class _Ti, class ..._Uj>
161 struct __mu_return_invokable<true, _Ti, _Uj...>
162 {
163     typedef typename __invoke_of<_Ti&, _Uj...>::type type;
164 };
165 
166 template <class _Ti, class ..._Uj>
167 struct __mu_return_impl<_Ti, false, true, false, tuple<_Uj...> >
168     : public __mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
169 {
170 };
171 
172 template <class _Ti, class _TupleUj>
173 struct __mu_return_impl<_Ti, false, false, true, _TupleUj>
174 {
175     typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
176                                    _TupleUj>::type&& type;
177 };
178 
179 template <class _Ti, class _TupleUj>
180 struct __mu_return_impl<_Ti, true, false, false, _TupleUj>
181 {
182     typedef typename _Ti::type& type;
183 };
184 
185 template <class _Ti, class _TupleUj>
186 struct __mu_return_impl<_Ti, false, false, false, _TupleUj>
187 {
188     typedef _Ti& type;
189 };
190 
191 template <class _Ti, class _TupleUj>
192 struct __mu_return
193     : public __mu_return_impl<_Ti,
194                               __is_reference_wrapper<_Ti>::value,
195                               is_bind_expression<_Ti>::value,
196                               0 < is_placeholder<_Ti>::value &&
197                               is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
198                               _TupleUj>
199 {
200 };
201 
202 template <class _Fp, class _BoundArgs, class _TupleUj>
203 struct __is_valid_bind_return
204 {
205     static const bool value = false;
206 };
207 
208 template <class _Fp, class ..._BoundArgs, class _TupleUj>
209 struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
210 {
211     static const bool value = __invokable<_Fp,
212                     typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
213 };
214 
215 template <class _Fp, class ..._BoundArgs, class _TupleUj>
216 struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
217 {
218     static const bool value = __invokable<_Fp,
219                     typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
220 };
221 
222 template <class _Fp, class _BoundArgs, class _TupleUj,
223           bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
224 struct __bind_return;
225 
226 template <class _Fp, class ..._BoundArgs, class _TupleUj>
227 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
228 {
229     typedef typename __invoke_of
230     <
231         _Fp&,
232         typename __mu_return
233         <
234             _BoundArgs,
235             _TupleUj
236         >::type...
237     >::type type;
238 };
239 
240 template <class _Fp, class ..._BoundArgs, class _TupleUj>
241 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
242 {
243     typedef typename __invoke_of
244     <
245         _Fp&,
246         typename __mu_return
247         <
248             const _BoundArgs,
249             _TupleUj
250         >::type...
251     >::type type;
252 };
253 
254 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
255 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
256 typename __bind_return<_Fp, _BoundArgs, _Args>::type
257 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
258                 _Args&& __args)
259 {
260     return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
261 }
262 
263 template<class _Fp, class ..._BoundArgs>
264 class __bind : public __weak_result_type<__decay_t<_Fp> >
265 {
266 protected:
267     using _Fd = __decay_t<_Fp>;
268     typedef tuple<__decay_t<_BoundArgs>...> _Td;
269 private:
270     _Fd __f_;
271     _Td __bound_args_;
272 
273     typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
274 public:
275     template <class _Gp, class ..._BA,
276               class = typename enable_if
277                                <
278                                   is_constructible<_Fd, _Gp>::value &&
279                                   !is_same<__libcpp_remove_reference_t<_Gp>,
280                                            __bind>::value
281                                >::type>
282       _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
283       explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
284         : __f_(_VSTD::forward<_Gp>(__f)),
285           __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
286 
287     template <class ..._Args>
288         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
289         typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
290         operator()(_Args&& ...__args)
291         {
292             return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
293                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
294         }
295 
296     template <class ..._Args>
297         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
298         typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
299         operator()(_Args&& ...__args) const
300         {
301             return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
302                                    tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
303         }
304 };
305 
306 template<class _Fp, class ..._BoundArgs>
307 struct is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
308 
309 template<class _Rp, class _Fp, class ..._BoundArgs>
310 class __bind_r
311     : public __bind<_Fp, _BoundArgs...>
312 {
313     typedef __bind<_Fp, _BoundArgs...> base;
314     typedef typename base::_Fd _Fd;
315     typedef typename base::_Td _Td;
316 public:
317     typedef _Rp result_type;
318 
319 
320     template <class _Gp, class ..._BA,
321               class = typename enable_if
322                                <
323                                   is_constructible<_Fd, _Gp>::value &&
324                                   !is_same<__libcpp_remove_reference_t<_Gp>,
325                                            __bind_r>::value
326                                >::type>
327       _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
328       explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
329         : base(_VSTD::forward<_Gp>(__f),
330                _VSTD::forward<_BA>(__bound_args)...) {}
331 
332     template <class ..._Args>
333         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
334         typename enable_if
335         <
336             is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
337                            result_type>::value || is_void<_Rp>::value,
338             result_type
339         >::type
340         operator()(_Args&& ...__args)
341         {
342             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
343             return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
344         }
345 
346     template <class ..._Args>
347         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
348         typename enable_if
349         <
350             is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
351                            result_type>::value || is_void<_Rp>::value,
352             result_type
353         >::type
354         operator()(_Args&& ...__args) const
355         {
356             typedef __invoke_void_return_wrapper<_Rp> _Invoker;
357             return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
358         }
359 };
360 
361 template<class _Rp, class _Fp, class ..._BoundArgs>
362 struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
363 
364 template<class _Fp, class ..._BoundArgs>
365 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
366 __bind<_Fp, _BoundArgs...>
367 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
368 {
369     typedef __bind<_Fp, _BoundArgs...> type;
370     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
371 }
372 
373 template<class _Rp, class _Fp, class ..._BoundArgs>
374 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX20
375 __bind_r<_Rp, _Fp, _BoundArgs...>
376 bind(_Fp&& __f, _BoundArgs&&... __bound_args)
377 {
378     typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
379     return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
380 }
381 
382 #endif // _LIBCPP_CXX03_LANG
383 
384 _LIBCPP_END_NAMESPACE_STD
385 
386 #endif // _LIBCPP___FUNCTIONAL_BIND_H
387