contrib/libc++/include/__functional_base

   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
  19 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  20 #pragma GCC system_header
  21 #endif
  22
  23 _LIBCPP_BEGIN_NAMESPACE_STD
  24
  25 template <class _Arg, class _Result>
  26 struct _LIBCPP_TYPE_VIS unary_function
  27 {
  28     typedef _Arg    argument_type;
  29     typedef _Result result_type;
  30 };
  31
  32 template <class _Arg1, class _Arg2, class _Result>
  33 struct _LIBCPP_TYPE_VIS binary_function
  34 {
  35     typedef _Arg1   first_argument_type;
  36     typedef _Arg2   second_argument_type;
  37     typedef _Result result_type;
  38 };
  39
  40 template <class _Tp> struct _LIBCPP_TYPE_VIS hash;
  41
  42 template <class _Tp>
  43 struct __has_result_type
  44 {
  45 private:
  46     struct __two {char __lx; char __lxx;};
  47     template <class _Up> static __two __test(...);
  48     template <class _Up> static char __test(typename _Up::result_type* = 0);
  49 public:
  50     static const bool value = sizeof(__test<_Tp>(0)) == 1;
  51 };
  52
  53 template <class _Tp>
  54 struct _LIBCPP_TYPE_VIS less : binary_function<_Tp, _Tp, bool>
  55 {
  56     _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
  57         {return __x < __y;}
  58 };
  59
  60 #ifdef _LIBCPP_HAS_NO_VARIADICS
  61
  62 #include <__functional_base_03>
  63
  64 #else  // _LIBCPP_HAS_NO_VARIADICS
  65
  66 // __weak_result_type
  67
  68 template <class _Tp>
  69 struct __derives_from_unary_function
  70 {
  71 private:
  72     struct __two {char __lx; char __lxx;};
  73     static __two __test(...);
  74     template <class _Ap, class _Rp>
  75         static unary_function<_Ap, _Rp>
  76         __test(const volatile unary_function<_Ap, _Rp>*);
  77 public:
  78     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
  79     typedef decltype(__test((_Tp*)0)) type;
  80 };
  81
  82 template <class _Tp>
  83 struct __derives_from_binary_function
  84 {
  85 private:
  86     struct __two {char __lx; char __lxx;};
  87     static __two __test(...);
  88     template <class _A1, class _A2, class _Rp>
  89         static binary_function<_A1, _A2, _Rp>
  90         __test(const volatile binary_function<_A1, _A2, _Rp>*);
  91 public:
  92     static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
  93     typedef decltype(__test((_Tp*)0)) type;
  94 };
  95
  96 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
  97 struct __maybe_derive_from_unary_function  // bool is true
  98     : public __derives_from_unary_function<_Tp>::type
  99 {
 100 };
 101
 102 template <class _Tp>
 103 struct __maybe_derive_from_unary_function<_Tp, false>
 104 {
 105 };
 106
 107 template <class _Tp, bool = __derives_from_binary_function<_Tp>::value>
 108 struct __maybe_derive_from_binary_function  // bool is true
 109     : public __derives_from_binary_function<_Tp>::type
 110 {
 111 };
 112
 113 template <class _Tp>
 114 struct __maybe_derive_from_binary_function<_Tp, false>
 115 {
 116 };
 117
 118 template <class _Tp, bool = __has_result_type<_Tp>::value>
 119 struct __weak_result_type_imp // bool is true
 120     : public __maybe_derive_from_unary_function<_Tp>,
 121       public __maybe_derive_from_binary_function<_Tp>
 122 {
 123     typedef typename _Tp::result_type result_type;
 124 };
 125
 126 template <class _Tp>
 127 struct __weak_result_type_imp<_Tp, false>
 128     : public __maybe_derive_from_unary_function<_Tp>,
 129       public __maybe_derive_from_binary_function<_Tp>
 130 {
 131 };
 132
 133 template <class _Tp>
 134 struct __weak_result_type
 135     : public __weak_result_type_imp<_Tp>
 136 {
 137 };
 138
 139 // 0 argument case
 140
 141 template <class _Rp>
 142 struct __weak_result_type<_Rp ()>
 143 {
 144     typedef _Rp result_type;
 145 };
 146
 147 template <class _Rp>
 148 struct __weak_result_type<_Rp (&)()>
 149 {
 150     typedef _Rp result_type;
 151 };
 152
 153 template <class _Rp>
 154 struct __weak_result_type<_Rp (*)()>
 155 {
 156     typedef _Rp result_type;
 157 };
 158
 159 // 1 argument case
 160
 161 template <class _Rp, class _A1>
 162 struct __weak_result_type<_Rp (_A1)>
 163     : public unary_function<_A1, _Rp>
 164 {
 165 };
 166
 167 template <class _Rp, class _A1>
 168 struct __weak_result_type<_Rp (&)(_A1)>
 169     : public unary_function<_A1, _Rp>
 170 {
 171 };
 172
 173 template <class _Rp, class _A1>
 174 struct __weak_result_type<_Rp (*)(_A1)>
 175     : public unary_function<_A1, _Rp>
 176 {
 177 };
 178
 179 template <class _Rp, class _Cp>
 180 struct __weak_result_type<_Rp (_Cp::*)()>
 181     : public unary_function<_Cp*, _Rp>
 182 {
 183 };
 184
 185 template <class _Rp, class _Cp>
 186 struct __weak_result_type<_Rp (_Cp::*)() const>
 187     : public unary_function<const _Cp*, _Rp>
 188 {
 189 };
 190
 191 template <class _Rp, class _Cp>
 192 struct __weak_result_type<_Rp (_Cp::*)() volatile>
 193     : public unary_function<volatile _Cp*, _Rp>
 194 {
 195 };
 196
 197 template <class _Rp, class _Cp>
 198 struct __weak_result_type<_Rp (_Cp::*)() const volatile>
 199     : public unary_function<const volatile _Cp*, _Rp>
 200 {
 201 };
 202
 203 // 2 argument case
 204
 205 template <class _Rp, class _A1, class _A2>
 206 struct __weak_result_type<_Rp (_A1, _A2)>
 207     : public binary_function<_A1, _A2, _Rp>
 208 {
 209 };
 210
 211 template <class _Rp, class _A1, class _A2>
 212 struct __weak_result_type<_Rp (*)(_A1, _A2)>
 213     : public binary_function<_A1, _A2, _Rp>
 214 {
 215 };
 216
 217 template <class _Rp, class _A1, class _A2>
 218 struct __weak_result_type<_Rp (&)(_A1, _A2)>
 219     : public binary_function<_A1, _A2, _Rp>
 220 {
 221 };
 222
 223 template <class _Rp, class _Cp, class _A1>
 224 struct __weak_result_type<_Rp (_Cp::*)(_A1)>
 225     : public binary_function<_Cp*, _A1, _Rp>
 226 {
 227 };
 228
 229 template <class _Rp, class _Cp, class _A1>
 230 struct __weak_result_type<_Rp (_Cp::*)(_A1) const>
 231     : public binary_function<const _Cp*, _A1, _Rp>
 232 {
 233 };
 234
 235 template <class _Rp, class _Cp, class _A1>
 236 struct __weak_result_type<_Rp (_Cp::*)(_A1) volatile>
 237     : public binary_function<volatile _Cp*, _A1, _Rp>
 238 {
 239 };
 240
 241 template <class _Rp, class _Cp, class _A1>
 242 struct __weak_result_type<_Rp (_Cp::*)(_A1) const volatile>
 243     : public binary_function<const volatile _Cp*, _A1, _Rp>
 244 {
 245 };
 246
 247 // 3 or more arguments
 248
 249 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 250 struct __weak_result_type<_Rp (_A1, _A2, _A3, _A4...)>
 251 {
 252     typedef _Rp result_type;
 253 };
 254
 255 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 256 struct __weak_result_type<_Rp (&)(_A1, _A2, _A3, _A4...)>
 257 {
 258     typedef _Rp result_type;
 259 };
 260
 261 template <class _Rp, class _A1, class _A2, class _A3, class ..._A4>
 262 struct __weak_result_type<_Rp (*)(_A1, _A2, _A3, _A4...)>
 263 {
 264     typedef _Rp result_type;
 265 };
 266
 267 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 268 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...)>
 269 {
 270     typedef _Rp result_type;
 271 };
 272
 273 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 274 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const>
 275 {
 276     typedef _Rp result_type;
 277 };
 278
 279 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 280 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) volatile>
 281 {
 282     typedef _Rp result_type;
 283 };
 284
 285 template <class _Rp, class _Cp, class _A1, class _A2, class ..._A3>
 286 struct __weak_result_type<_Rp (_Cp::*)(_A1, _A2, _A3...) const volatile>
 287 {
 288     typedef _Rp result_type;
 289 };
 290
 291 // __invoke
 292
 293 // bullets 1 and 2
 294
 295 template <class _Fp, class _A0, class ..._Args,
 296             class>
 297 inline _LIBCPP_INLINE_VISIBILITY
 298 auto
 299 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
 300     -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
 301 {
 302     return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
 303 }
 304
 305 template <class _Fp, class _A0, class ..._Args,
 306             class>
 307 inline _LIBCPP_INLINE_VISIBILITY
 308 auto
 309 __invoke(_Fp&& __f, _A0&& __a0, _Args&& ...__args)
 310     -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
 311 {
 312     return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
 313 }
 314
 315 // bullets 3 and 4
 316
 317 template <class _Fp, class _A0,
 318             class>
 319 inline _LIBCPP_INLINE_VISIBILITY
 320 auto
 321 __invoke(_Fp&& __f, _A0&& __a0)
 322     -> decltype(_VSTD::forward<_A0>(__a0).*__f)
 323 {
 324     return _VSTD::forward<_A0>(__a0).*__f;
 325 }
 326
 327 template <class _Fp, class _A0,
 328             class>
 329 inline _LIBCPP_INLINE_VISIBILITY
 330 auto
 331 __invoke(_Fp&& __f, _A0&& __a0)
 332     -> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
 333 {
 334     return (*_VSTD::forward<_A0>(__a0)).*__f;
 335 }
 336
 337 // bullet 5
 338
 339 template <class _Fp, class ..._Args>
 340 inline _LIBCPP_INLINE_VISIBILITY
 341 auto
 342 __invoke(_Fp&& __f, _Args&& ...__args)
 343     -> decltype(_VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...))
 344 {
 345     return _VSTD::forward<_Fp>(__f)(_VSTD::forward<_Args>(__args)...);
 346 }
 347
 348 template <class _Tp, class ..._Args>
 349 struct __invoke_return
 350 {
 351     typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
 352 };
 353
 354 template <class _Tp>
 355 class _LIBCPP_TYPE_VIS reference_wrapper
 356     : public __weak_result_type<_Tp>
 357 {
 358 public:
 359     // types
 360     typedef _Tp type;
 361 private:
 362     type* __f_;
 363
 364 public:
 365     // construct/copy/destroy
 366     _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT : __f_(&__f) {}
 367 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 368     private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
 369 #endif
 370
 371     // access
 372     _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
 373     _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
 374
 375     // invoke
 376     template <class... _ArgTypes>
 377        _LIBCPP_INLINE_VISIBILITY
 378        typename __invoke_of<type&, _ArgTypes...>::type
 379           operator() (_ArgTypes&&... __args) const
 380           {
 381               return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
 382           }
 383 };
 384
 385 template <class _Tp> struct ____is_reference_wrapper : public false_type {};
 386 template <class _Tp> struct ____is_reference_wrapper<reference_wrapper<_Tp> > : public true_type {};
 387 template <class _Tp> struct __is_reference_wrapper
 388     : public ____is_reference_wrapper<typename remove_cv<_Tp>::type> {};
 389
 390 template <class _Tp>
 391 inline _LIBCPP_INLINE_VISIBILITY
 392 reference_wrapper<_Tp>
 393 ref(_Tp& __t) _NOEXCEPT
 394 {
 395     return reference_wrapper<_Tp>(__t);
 396 }
 397
 398 template <class _Tp>
 399 inline _LIBCPP_INLINE_VISIBILITY
 400 reference_wrapper<_Tp>
 401 ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 402 {
 403     return ref(__t.get());
 404 }
 405
 406 template <class _Tp>
 407 inline _LIBCPP_INLINE_VISIBILITY
 408 reference_wrapper<const _Tp>
 409 cref(const _Tp& __t) _NOEXCEPT
 410 {
 411     return reference_wrapper<const _Tp>(__t);
 412 }
 413
 414 template <class _Tp>
 415 inline _LIBCPP_INLINE_VISIBILITY
 416 reference_wrapper<const _Tp>
 417 cref(reference_wrapper<_Tp> __t) _NOEXCEPT
 418 {
 419     return cref(__t.get());
 420 }
 421
 422 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 423 #ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 424
 425 template <class _Tp> void ref(const _Tp&&) = delete;
 426 template <class _Tp> void cref(const _Tp&&) = delete;
 427
 428 #else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 429
 430 template <class _Tp> void ref(const _Tp&&);// = delete;
 431 template <class _Tp> void cref(const _Tp&&);// = delete;
 432
 433 #endif  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 434
 435 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 436
 437 #endif  // _LIBCPP_HAS_NO_VARIADICS
 438
 439 _LIBCPP_END_NAMESPACE_STD
 440
 441 #endif  // _LIBCPP_FUNCTIONAL_BASE