• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// -*- C++ -*-
2//===----------------------------------------------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_FUNCTIONAL_BASE
12#define _LIBCPP_FUNCTIONAL_BASE
13
14#include <__config>
15#include <type_traits>
16#include <typeinfo>
17#include <exception>
18#include <new>
19#include <utility>
20
21#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
22#pragma GCC system_header
23#endif
24
25_LIBCPP_BEGIN_NAMESPACE_STD
26
27template <class _Arg1, class _Arg2, class _Result>
28struct _LIBCPP_TEMPLATE_VIS binary_function
29{
30    typedef _Arg1   first_argument_type;
31    typedef _Arg2   second_argument_type;
32    typedef _Result result_type;
33};
34
35template <class _Tp>
36struct __has_result_type
37{
38private:
39    struct __two {char __lx; char __lxx;};
40    template <class _Up> static __two __test(...);
41    template <class _Up> static char __test(typename _Up::result_type* = 0);
42public:
43    static const bool value = sizeof(__test<_Tp>(0)) == 1;
44};
45
46#if _LIBCPP_STD_VER > 11
47template <class _Tp = void>
48#else
49template <class _Tp>
50#endif
51struct _LIBCPP_TEMPLATE_VIS less : binary_function<_Tp, _Tp, bool>
52{
53    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
54    bool operator()(const _Tp& __x, const _Tp& __y) const
55        {return __x < __y;}
56};
57
58#if _LIBCPP_STD_VER > 11
59template <>
60struct _LIBCPP_TEMPLATE_VIS less<void>
61{
62    template <class _T1, class _T2>
63    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
64    auto operator()(_T1&& __t, _T2&& __u) const
65    _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)))
66    -> decltype        (_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))
67        { return        _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
68    typedef void is_transparent;
69};
70#endif
71
72// __weak_result_type
73
74template <class _Tp>
75struct __derives_from_unary_function
76{
77private:
78    struct __two {char __lx; char __lxx;};
79    static __two __test(...);
80    template <class _Ap, class _Rp>
81        static unary_function<_Ap, _Rp>
82        __test(const volatile unary_function<_Ap, _Rp>*);
83public:
84    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
85    typedef decltype(__test((_Tp*)0)) type;
86};
87
88template <class _Tp>
89struct __derives_from_binary_function
90{
91private:
92    struct __two {char __lx; char __lxx;};
93    static __two __test(...);
94    template <class _A1, class _A2, class _Rp>
95        static binary_function<_A1, _A2, _Rp>
96        __test(const volatile binary_function<_A1, _A2, _Rp>*);
97public:
98    static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
99    typedef decltype(__test((_Tp*)0)) type;
100};
101
102template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
103struct __maybe_derive_from_unary_function  // bool is true
104    : public __derives_from_unary_function<_Tp>::type
105{
106};
107
108template <class _Tp>
109struct __maybe_derive_from_unary_function<_Tp, false>
110{
111};
112
113template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
114struct __maybe_derive_from_binary_function  // bool is true
115    : public __derives_from_binary_function<_Tp>::type
116{
117};
118
119template <class _Tp>
120struct __maybe_derive_from_binary_function<_Tp, false>
121{
122};
123
124template <class _Tp, bool = __has_result_type<_Tp>::value>
125struct __weak_result_type_imp // bool is true
126    : public __maybe_derive_from_unary_function<_Tp>,
127      public __maybe_derive_from_binary_function<_Tp>
128{
129    typedef typename _Tp::result_type result_type;
130};
131
132template <class _Tp>
133struct __weak_result_type_imp<_Tp, false>
134    : public __maybe_derive_from_unary_function<_Tp>,
135      public __maybe_derive_from_binary_function<_Tp>
136{
137};
138
139template <class _Tp>
140struct __weak_result_type
141    : public __weak_result_type_imp<_Tp>
142{
143};
144
145// 0 argument case
146
147template <class _Rp>
148struct __weak_result_type<_Rp ()>
149{
150    typedef _Rp result_type;
151};
152
153template <class _Rp>
154struct __weak_result_type<_Rp (&)()>
155{
156    typedef _Rp result_type;
157};
158
159template <class _Rp>
160struct __weak_result_type<_Rp (*)()>
161{
162    typedef _Rp result_type;
163};
164
165// 1 argument case
166
167template <class _Rp, class _A1>
168struct __weak_result_type<_Rp (_A1)>
169    : public unary_function<_A1, _Rp>
170{
171};
172
173template <class _Rp, class _A1>
174struct __weak_result_type<_Rp (&)(_A1)>
175    : public unary_function<_A1, _Rp>
176{
177};
178
179template <class _Rp, class _A1>
180struct __weak_result_type<_Rp (*)(_A1)>
181    : public unary_function<_A1, _Rp>
182{
183};
184
185template <class _Rp, class _Cp>
186struct __weak_result_type<_Rp (_Cp::*)()>
187    : public unary_function<_Cp*, _Rp>
188{
189};
190
191template <class _Rp, class _Cp>
192struct __weak_result_type<_Rp (_Cp::*)() const>
193    : public unary_function<const _Cp*, _Rp>
194{
195};
196
197template <class _Rp, class _Cp>
198struct __weak_result_type<_Rp (_Cp::*)() volatile>
199    : public unary_function<volatile _Cp*, _Rp>
200{
201};
202
203template <class _Rp, class _Cp>
204struct __weak_result_type<_Rp (_Cp::*)() const volatile>
205    : public unary_function<const volatile _Cp*, _Rp>
206{
207};
208
209// 2 argument case
210
211template <class _Rp, class _A1, class _A2>
212struct __weak_result_type<_Rp (_A1, _A2)>
213    : public binary_function<_A1, _A2, _Rp>
214{
215};
216
217template <class _Rp, class _A1, class _A2>
218struct __weak_result_type<_Rp (*)(_A1, _A2)>
219    : public binary_function<_A1, _A2, _Rp>
220{
221};
222
223template <class _Rp, class _A1, class _A2>
224struct __weak_result_type<_Rp (&)(_A1, _A2)>
225    : public binary_function<_A1, _A2, _Rp>
226{
227};
228
229template <class _Rp, class _Cp, class _A1>
230struct __weak_result_type<_Rp (_Cp::*)(_A1)>
231    : public binary_function<_Cp*, _A1, _Rp>
232{
233};
234
235template <class _Rp, class _Cp, class _A1>
236struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
237    : public binary_function<const _Cp*, _A1, _Rp>
238{
239};
240
241template <class _Rp, class _Cp, class _A1>
242struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
243    : public binary_function<volatile _Cp*, _A1, _Rp>
244{
245};
246
247template <class _Rp, class _Cp, class _A1>
248struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
249    : public binary_function<const volatile _Cp*, _A1, _Rp>
250{
251};
252
253
254#ifndef _LIBCPP_CXX03_LANG
255// 3 or more arguments
256
257template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
258struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
259{
260    typedef _Rp result_type;
261};
262
263template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
264struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
265{
266    typedef _Rp result_type;
267};
268
269template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
270struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
271{
272    typedef _Rp result_type;
273};
274
275template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
276struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
277{
278    typedef _Rp result_type;
279};
280
281template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
282struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
283{
284    typedef _Rp result_type;
285};
286
287template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
288struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
289{
290    typedef _Rp result_type;
291};
292
293template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
294struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
295{
296    typedef _Rp result_type;
297};
298
299template <class _Tp, class ..._Args>
300struct __invoke_return
301{
302    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
303};
304
305#else // defined(_LIBCPP_CXX03_LANG)
306
307#include <__functional_base_03>
308
309#endif  // !defined(_LIBCPP_CXX03_LANG)
310
311
312template <class _Ret>
313struct __invoke_void_return_wrapper
314{
315#ifndef _LIBCPP_CXX03_LANG
316    template <class ..._Args>
317    static _Ret __call(_Args&&... __args) {
318        return __invoke(_VSTD::forward<_Args>(__args)...);
319    }
320#else
321    template <class _Fn>
322    static _Ret __call(_Fn __f) {
323        return __invoke(__f);
324    }
325
326    template <class _Fn, class _A0>
327    static _Ret __call(_Fn __f, _A0& __a0) {
328        return __invoke(__f, __a0);
329    }
330
331    template <class _Fn, class _A0, class _A1>
332    static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1) {
333        return __invoke(__f, __a0, __a1);
334    }
335
336    template <class _Fn, class _A0, class _A1, class _A2>
337    static _Ret __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2){
338        return __invoke(__f, __a0, __a1, __a2);
339    }
340#endif
341};
342
343template <>
344struct __invoke_void_return_wrapper<void>
345{
346#ifndef _LIBCPP_CXX03_LANG
347    template <class ..._Args>
348    static void __call(_Args&&... __args) {
349        __invoke(_VSTD::forward<_Args>(__args)...);
350    }
351#else
352    template <class _Fn>
353    static void __call(_Fn __f) {
354        __invoke(__f);
355    }
356
357    template <class _Fn, class _A0>
358    static void __call(_Fn __f, _A0& __a0) {
359        __invoke(__f, __a0);
360    }
361
362    template <class _Fn, class _A0, class _A1>
363    static void __call(_Fn __f, _A0& __a0, _A1& __a1) {
364        __invoke(__f, __a0, __a1);
365    }
366
367    template <class _Fn, class _A0, class _A1, class _A2>
368    static void __call(_Fn __f, _A0& __a0, _A1& __a1, _A2& __a2) {
369        __invoke(__f, __a0, __a1, __a2);
370    }
371#endif
372};
373
374template <class _Tp>
375class _LIBCPP_TEMPLATE_VIS reference_wrapper
376    : public __weak_result_type<_Tp>
377{
378public:
379    // types
380    typedef _Tp type;
381private:
382    type* __f_;
383
384public:
385    // construct/copy/destroy
386    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT
387        : __f_(_VSTD::addressof(__f)) {}
388#ifndef _LIBCPP_CXX03_LANG
389    private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
390#endif
391
392    // access
393    _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
394    _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
395
396#ifndef _LIBCPP_CXX03_LANG
397    // invoke
398    template <class... _ArgTypes>
399    _LIBCPP_INLINE_VISIBILITY
400    typename __invoke_of<type&, _ArgTypes...>::type
401    operator() (_ArgTypes&&... __args) const {
402        return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
403    }
404#else
405
406    _LIBCPP_INLINE_VISIBILITY
407    typename __invoke_return<type>::type
408    operator() () const {
409        return __invoke(get());
410    }
411
412    template <class _A0>
413    _LIBCPP_INLINE_VISIBILITY
414    typename __invoke_return0<type, _A0>::type
415    operator() (_A0& __a0) const {
416        return __invoke(get(), __a0);
417    }
418
419    template <class _A0>
420    _LIBCPP_INLINE_VISIBILITY
421    typename __invoke_return0<type, _A0 const>::type
422    operator() (_A0 const& __a0) const {
423        return __invoke(get(), __a0);
424    }
425
426    template <class _A0, class _A1>
427    _LIBCPP_INLINE_VISIBILITY
428    typename __invoke_return1<type, _A0, _A1>::type
429    operator() (_A0& __a0, _A1& __a1) const {
430        return __invoke(get(), __a0, __a1);
431    }
432
433    template <class _A0, class _A1>
434    _LIBCPP_INLINE_VISIBILITY
435    typename __invoke_return1<type, _A0 const, _A1>::type
436    operator() (_A0 const& __a0, _A1& __a1) const {
437        return __invoke(get(), __a0, __a1);
438    }
439
440    template <class _A0, class _A1>
441    _LIBCPP_INLINE_VISIBILITY
442    typename __invoke_return1<type, _A0, _A1 const>::type
443    operator() (_A0& __a0, _A1 const& __a1) const {
444        return __invoke(get(), __a0, __a1);
445    }
446
447    template <class _A0, class _A1>
448    _LIBCPP_INLINE_VISIBILITY
449    typename __invoke_return1<type, _A0 const, _A1 const>::type
450    operator() (_A0 const& __a0, _A1 const& __a1) const {
451        return __invoke(get(), __a0, __a1);
452    }
453
454    template <class _A0, class _A1, class _A2>
455    _LIBCPP_INLINE_VISIBILITY
456    typename __invoke_return2<type, _A0, _A1, _A2>::type
457    operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
458        return __invoke(get(), __a0, __a1, __a2);
459    }
460
461    template <class _A0, class _A1, class _A2>
462    _LIBCPP_INLINE_VISIBILITY
463    typename __invoke_return2<type, _A0 const, _A1, _A2>::type
464    operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
465        return __invoke(get(), __a0, __a1, __a2);
466    }
467
468    template <class _A0, class _A1, class _A2>
469    _LIBCPP_INLINE_VISIBILITY
470    typename __invoke_return2<type, _A0, _A1 const, _A2>::type
471    operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
472        return __invoke(get(), __a0, __a1, __a2);
473    }
474
475    template <class _A0, class _A1, class _A2>
476    _LIBCPP_INLINE_VISIBILITY
477    typename __invoke_return2<type, _A0, _A1, _A2 const>::type
478    operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
479        return __invoke(get(), __a0, __a1, __a2);
480    }
481
482    template <class _A0, class _A1, class _A2>
483    _LIBCPP_INLINE_VISIBILITY
484    typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
485    operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
486        return __invoke(get(), __a0, __a1, __a2);
487    }
488
489    template <class _A0, class _A1, class _A2>
490    _LIBCPP_INLINE_VISIBILITY
491    typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
492    operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
493        return __invoke(get(), __a0, __a1, __a2);
494    }
495
496    template <class _A0, class _A1, class _A2>
497    _LIBCPP_INLINE_VISIBILITY
498    typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
499    operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
500        return __invoke(get(), __a0, __a1, __a2);
501    }
502
503    template <class _A0, class _A1, class _A2>
504    _LIBCPP_INLINE_VISIBILITY
505    typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
506    operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
507        return __invoke(get(), __a0, __a1, __a2);
508    }
509#endif // _LIBCPP_CXX03_LANG
510};
511
512
513template <class _Tp>
514inline _LIBCPP_INLINE_VISIBILITY
515reference_wrapper<_Tp>
516ref(_Tp& __t) _NOEXCEPT
517{
518    return reference_wrapper<_Tp>(__t);
519}
520
521template <class _Tp>
522inline _LIBCPP_INLINE_VISIBILITY
523reference_wrapper<_Tp>
524ref(reference_wrapper<_Tp> __t) _NOEXCEPT
525{
526    return ref(__t.get());
527}
528
529template <class _Tp>
530inline _LIBCPP_INLINE_VISIBILITY
531reference_wrapper<const _Tp>
532cref(const _Tp& __t) _NOEXCEPT
533{
534    return reference_wrapper<const _Tp>(__t);
535}
536
537template <class _Tp>
538inline _LIBCPP_INLINE_VISIBILITY
539reference_wrapper<const _Tp>
540cref(reference_wrapper<_Tp> __t) _NOEXCEPT
541{
542    return cref(__t.get());
543}
544
545#ifndef _LIBCPP_CXX03_LANG
546template <class _Tp> void ref(const _Tp&&) = delete;
547template <class _Tp> void cref(const _Tp&&) = delete;
548#endif
549
550#if _LIBCPP_STD_VER > 11
551template <class _Tp, class, class = void>
552struct __is_transparent : false_type {};
553
554template <class _Tp, class _Up>
555struct __is_transparent<_Tp, _Up,
556                        typename __void_t<typename _Tp::is_transparent>::type>
557   : true_type {};
558#endif
559
560// allocator_arg_t
561
562struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { };
563
564#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_MEMORY)
565extern const allocator_arg_t allocator_arg;
566#else
567/* _LIBCPP_INLINE_VAR */ constexpr allocator_arg_t allocator_arg = allocator_arg_t();
568#endif
569
570// uses_allocator
571
572template <class _Tp>
573struct __has_allocator_type
574{
575private:
576    struct __two {char __lx; char __lxx;};
577    template <class _Up> static __two __test(...);
578    template <class _Up> static char __test(typename _Up::allocator_type* = 0);
579public:
580    static const bool value = sizeof(__test<_Tp>(0)) == 1;
581};
582
583template <class _Tp, class _Alloc, bool = __has_allocator_type<_Tp>::value>
584struct __uses_allocator
585    : public integral_constant<bool,
586        is_convertible<_Alloc, typename _Tp::allocator_type>::value>
587{
588};
589
590template <class _Tp, class _Alloc>
591struct __uses_allocator<_Tp, _Alloc, false>
592    : public false_type
593{
594};
595
596template <class _Tp, class _Alloc>
597struct _LIBCPP_TEMPLATE_VIS uses_allocator
598    : public __uses_allocator<_Tp, _Alloc>
599{
600};
601
602#if _LIBCPP_STD_VER > 14
603template <class _Tp, class _Alloc>
604_LIBCPP_INLINE_VAR constexpr size_t uses_allocator_v = uses_allocator<_Tp, _Alloc>::value;
605#endif
606
607#ifndef _LIBCPP_CXX03_LANG
608
609// allocator construction
610
611template <class _Tp, class _Alloc, class ..._Args>
612struct __uses_alloc_ctor_imp
613{
614    typedef typename __uncvref<_Alloc>::type _RawAlloc;
615    static const bool __ua = uses_allocator<_Tp, _RawAlloc>::value;
616    static const bool __ic =
617        is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
618    static const int value = __ua ? 2 - __ic : 0;
619};
620
621template <class _Tp, class _Alloc, class ..._Args>
622struct __uses_alloc_ctor
623    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
624    {};
625
626template <class _Tp, class _Allocator, class... _Args>
627inline _LIBCPP_INLINE_VISIBILITY
628void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
629{
630    new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
631}
632
633// FIXME: This should have a version which takes a non-const alloc.
634template <class _Tp, class _Allocator, class... _Args>
635inline _LIBCPP_INLINE_VISIBILITY
636void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
637{
638    new (__storage) _Tp (allocator_arg, __a, _VSTD::forward<_Args>(__args)...);
639}
640
641// FIXME: This should have a version which takes a non-const alloc.
642template <class _Tp, class _Allocator, class... _Args>
643inline _LIBCPP_INLINE_VISIBILITY
644void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
645{
646    new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
647}
648
649// FIXME: Theis should have a version which takes a non-const alloc.
650template <class _Tp, class _Allocator, class... _Args>
651inline _LIBCPP_INLINE_VISIBILITY
652void __user_alloc_construct (_Tp *__storage, const _Allocator &__a, _Args &&... __args)
653{
654    __user_alloc_construct_impl(
655             __uses_alloc_ctor<_Tp, _Allocator>(),
656             __storage, __a, _VSTD::forward<_Args>(__args)...
657        );
658}
659#endif  // _LIBCPP_CXX03_LANG
660
661_LIBCPP_END_NAMESPACE_STD
662
663#endif  // _LIBCPP_FUNCTIONAL_BASE
664