| OLD | NEW |
|---|
| (Empty) | |
| 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_03 |
| 12 #define _LIBCPP_FUNCTIONAL_03 |
| 13 |
| 14 // manual variadic expansion for <functional> |
| 15 |
| 16 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) |
| 17 #pragma GCC system_header |
| 18 #endif |
| 19 |
| 20 template <class _Tp> |
| 21 class __mem_fn |
| 22 : public __weak_result_type<_Tp> |
| 23 { |
| 24 public: |
| 25 // types |
| 26 typedef _Tp type; |
| 27 private: |
| 28 type __f_; |
| 29 |
| 30 public: |
| 31 _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {} |
| 32 |
| 33 // invoke |
| 34 |
| 35 typename __invoke_return<type>::type |
| 36 operator() () |
| 37 { |
| 38 return __invoke(__f_); |
| 39 } |
| 40 |
| 41 template <class _A0> |
| 42 typename __invoke_return0<type, _A0>::type |
| 43 operator() (_A0& __a0) |
| 44 { |
| 45 return __invoke(__f_, __a0); |
| 46 } |
| 47 |
| 48 template <class _A0, class _A1> |
| 49 typename __invoke_return1<type, _A0, _A1>::type |
| 50 operator() (_A0& __a0, _A1& __a1) |
| 51 { |
| 52 return __invoke(__f_, __a0, __a1); |
| 53 } |
| 54 |
| 55 template <class _A0, class _A1, class _A2> |
| 56 typename __invoke_return2<type, _A0, _A1, _A2>::type |
| 57 operator() (_A0& __a0, _A1& __a1, _A2& __a2) |
| 58 { |
| 59 return __invoke(__f_, __a0, __a1, __a2); |
| 60 } |
| 61 }; |
| 62 |
| 63 template<class _Rp, class _Tp> |
| 64 inline _LIBCPP_INLINE_VISIBILITY |
| 65 __mem_fn<_Rp _Tp::*> |
| 66 mem_fn(_Rp _Tp::* __pm) |
| 67 { |
| 68 return __mem_fn<_Rp _Tp::*>(__pm); |
| 69 } |
| 70 |
| 71 template<class _Rp, class _Tp> |
| 72 inline _LIBCPP_INLINE_VISIBILITY |
| 73 __mem_fn<_Rp (_Tp::*)()> |
| 74 mem_fn(_Rp (_Tp::* __pm)()) |
| 75 { |
| 76 return __mem_fn<_Rp (_Tp::*)()>(__pm); |
| 77 } |
| 78 |
| 79 template<class _Rp, class _Tp, class _A0> |
| 80 inline _LIBCPP_INLINE_VISIBILITY |
| 81 __mem_fn<_Rp (_Tp::*)(_A0)> |
| 82 mem_fn(_Rp (_Tp::* __pm)(_A0)) |
| 83 { |
| 84 return __mem_fn<_Rp (_Tp::*)(_A0)>(__pm); |
| 85 } |
| 86 |
| 87 template<class _Rp, class _Tp, class _A0, class _A1> |
| 88 inline _LIBCPP_INLINE_VISIBILITY |
| 89 __mem_fn<_Rp (_Tp::*)(_A0, _A1)> |
| 90 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1)) |
| 91 { |
| 92 return __mem_fn<_Rp (_Tp::*)(_A0, _A1)>(__pm); |
| 93 } |
| 94 |
| 95 template<class _Rp, class _Tp, class _A0, class _A1, class _A2> |
| 96 inline _LIBCPP_INLINE_VISIBILITY |
| 97 __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2)> |
| 98 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2)) |
| 99 { |
| 100 return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2)>(__pm); |
| 101 } |
| 102 |
| 103 template<class _Rp, class _Tp> |
| 104 inline _LIBCPP_INLINE_VISIBILITY |
| 105 __mem_fn<_Rp (_Tp::*)() const> |
| 106 mem_fn(_Rp (_Tp::* __pm)() const) |
| 107 { |
| 108 return __mem_fn<_Rp (_Tp::*)() const>(__pm); |
| 109 } |
| 110 |
| 111 template<class _Rp, class _Tp, class _A0> |
| 112 inline _LIBCPP_INLINE_VISIBILITY |
| 113 __mem_fn<_Rp (_Tp::*)(_A0) const> |
| 114 mem_fn(_Rp (_Tp::* __pm)(_A0) const) |
| 115 { |
| 116 return __mem_fn<_Rp (_Tp::*)(_A0) const>(__pm); |
| 117 } |
| 118 |
| 119 template<class _Rp, class _Tp, class _A0, class _A1> |
| 120 inline _LIBCPP_INLINE_VISIBILITY |
| 121 __mem_fn<_Rp (_Tp::*)(_A0, _A1) const> |
| 122 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) const) |
| 123 { |
| 124 return __mem_fn<_Rp (_Tp::*)(_A0, _A1) const>(__pm); |
| 125 } |
| 126 |
| 127 template<class _Rp, class _Tp, class _A0, class _A1, class _A2> |
| 128 inline _LIBCPP_INLINE_VISIBILITY |
| 129 __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const> |
| 130 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) const) |
| 131 { |
| 132 return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const>(__pm); |
| 133 } |
| 134 |
| 135 template<class _Rp, class _Tp> |
| 136 inline _LIBCPP_INLINE_VISIBILITY |
| 137 __mem_fn<_Rp (_Tp::*)() volatile> |
| 138 mem_fn(_Rp (_Tp::* __pm)() volatile) |
| 139 { |
| 140 return __mem_fn<_Rp (_Tp::*)() volatile>(__pm); |
| 141 } |
| 142 |
| 143 template<class _Rp, class _Tp, class _A0> |
| 144 inline _LIBCPP_INLINE_VISIBILITY |
| 145 __mem_fn<_Rp (_Tp::*)(_A0) volatile> |
| 146 mem_fn(_Rp (_Tp::* __pm)(_A0) volatile) |
| 147 { |
| 148 return __mem_fn<_Rp (_Tp::*)(_A0) volatile>(__pm); |
| 149 } |
| 150 |
| 151 template<class _Rp, class _Tp, class _A0, class _A1> |
| 152 inline _LIBCPP_INLINE_VISIBILITY |
| 153 __mem_fn<_Rp (_Tp::*)(_A0, _A1) volatile> |
| 154 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) volatile) |
| 155 { |
| 156 return __mem_fn<_Rp (_Tp::*)(_A0, _A1) volatile>(__pm); |
| 157 } |
| 158 |
| 159 template<class _Rp, class _Tp, class _A0, class _A1, class _A2> |
| 160 inline _LIBCPP_INLINE_VISIBILITY |
| 161 __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) volatile> |
| 162 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) volatile) |
| 163 { |
| 164 return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) volatile>(__pm); |
| 165 } |
| 166 |
| 167 template<class _Rp, class _Tp> |
| 168 inline _LIBCPP_INLINE_VISIBILITY |
| 169 __mem_fn<_Rp (_Tp::*)() const volatile> |
| 170 mem_fn(_Rp (_Tp::* __pm)() const volatile) |
| 171 { |
| 172 return __mem_fn<_Rp (_Tp::*)() const volatile>(__pm); |
| 173 } |
| 174 |
| 175 template<class _Rp, class _Tp, class _A0> |
| 176 inline _LIBCPP_INLINE_VISIBILITY |
| 177 __mem_fn<_Rp (_Tp::*)(_A0) const volatile> |
| 178 mem_fn(_Rp (_Tp::* __pm)(_A0) const volatile) |
| 179 { |
| 180 return __mem_fn<_Rp (_Tp::*)(_A0) const volatile>(__pm); |
| 181 } |
| 182 |
| 183 template<class _Rp, class _Tp, class _A0, class _A1> |
| 184 inline _LIBCPP_INLINE_VISIBILITY |
| 185 __mem_fn<_Rp (_Tp::*)(_A0, _A1) const volatile> |
| 186 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1) const volatile) |
| 187 { |
| 188 return __mem_fn<_Rp (_Tp::*)(_A0, _A1) const volatile>(__pm); |
| 189 } |
| 190 |
| 191 template<class _Rp, class _Tp, class _A0, class _A1, class _A2> |
| 192 inline _LIBCPP_INLINE_VISIBILITY |
| 193 __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const volatile> |
| 194 mem_fn(_Rp (_Tp::* __pm)(_A0, _A1, _A2) const volatile) |
| 195 { |
| 196 return __mem_fn<_Rp (_Tp::*)(_A0, _A1, _A2) const volatile>(__pm); |
| 197 } |
| 198 |
| 199 // bad_function_call |
| 200 |
| 201 class _LIBCPP_EXCEPTION_ABI bad_function_call |
| 202 : public exception |
| 203 { |
| 204 }; |
| 205 |
| 206 template<class _Fp> class _LIBCPP_TYPE_VIS_ONLY function; // undefined |
| 207 |
| 208 namespace __function |
| 209 { |
| 210 |
| 211 template<class _Fp> |
| 212 struct __maybe_derive_from_unary_function |
| 213 { |
| 214 }; |
| 215 |
| 216 template<class _Rp, class _A1> |
| 217 struct __maybe_derive_from_unary_function<_Rp(_A1)> |
| 218 : public unary_function<_A1, _Rp> |
| 219 { |
| 220 }; |
| 221 |
| 222 template<class _Fp> |
| 223 struct __maybe_derive_from_binary_function |
| 224 { |
| 225 }; |
| 226 |
| 227 template<class _Rp, class _A1, class _A2> |
| 228 struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> |
| 229 : public binary_function<_A1, _A2, _Rp> |
| 230 { |
| 231 }; |
| 232 |
| 233 template<class _Fp> class __base; |
| 234 |
| 235 template<class _Rp> |
| 236 class __base<_Rp()> |
| 237 { |
| 238 __base(const __base&); |
| 239 __base& operator=(const __base&); |
| 240 public: |
| 241 __base() {} |
| 242 virtual ~__base() {} |
| 243 virtual __base* __clone() const = 0; |
| 244 virtual void __clone(__base*) const = 0; |
| 245 virtual void destroy() = 0; |
| 246 virtual void destroy_deallocate() = 0; |
| 247 virtual _Rp operator()() = 0; |
| 248 #ifndef _LIBCPP_NO_RTTI |
| 249 virtual const void* target(const type_info&) const = 0; |
| 250 virtual const std::type_info& target_type() const = 0; |
| 251 #endif // _LIBCPP_NO_RTTI |
| 252 }; |
| 253 |
| 254 template<class _Rp, class _A0> |
| 255 class __base<_Rp(_A0)> |
| 256 { |
| 257 __base(const __base&); |
| 258 __base& operator=(const __base&); |
| 259 public: |
| 260 __base() {} |
| 261 virtual ~__base() {} |
| 262 virtual __base* __clone() const = 0; |
| 263 virtual void __clone(__base*) const = 0; |
| 264 virtual void destroy() = 0; |
| 265 virtual void destroy_deallocate() = 0; |
| 266 virtual _Rp operator()(_A0) = 0; |
| 267 #ifndef _LIBCPP_NO_RTTI |
| 268 virtual const void* target(const type_info&) const = 0; |
| 269 virtual const std::type_info& target_type() const = 0; |
| 270 #endif // _LIBCPP_NO_RTTI |
| 271 }; |
| 272 |
| 273 template<class _Rp, class _A0, class _A1> |
| 274 class __base<_Rp(_A0, _A1)> |
| 275 { |
| 276 __base(const __base&); |
| 277 __base& operator=(const __base&); |
| 278 public: |
| 279 __base() {} |
| 280 virtual ~__base() {} |
| 281 virtual __base* __clone() const = 0; |
| 282 virtual void __clone(__base*) const = 0; |
| 283 virtual void destroy() = 0; |
| 284 virtual void destroy_deallocate() = 0; |
| 285 virtual _Rp operator()(_A0, _A1) = 0; |
| 286 #ifndef _LIBCPP_NO_RTTI |
| 287 virtual const void* target(const type_info&) const = 0; |
| 288 virtual const std::type_info& target_type() const = 0; |
| 289 #endif // _LIBCPP_NO_RTTI |
| 290 }; |
| 291 |
| 292 template<class _Rp, class _A0, class _A1, class _A2> |
| 293 class __base<_Rp(_A0, _A1, _A2)> |
| 294 { |
| 295 __base(const __base&); |
| 296 __base& operator=(const __base&); |
| 297 public: |
| 298 __base() {} |
| 299 virtual ~__base() {} |
| 300 virtual __base* __clone() const = 0; |
| 301 virtual void __clone(__base*) const = 0; |
| 302 virtual void destroy() = 0; |
| 303 virtual void destroy_deallocate() = 0; |
| 304 virtual _Rp operator()(_A0, _A1, _A2) = 0; |
| 305 #ifndef _LIBCPP_NO_RTTI |
| 306 virtual const void* target(const type_info&) const = 0; |
| 307 virtual const std::type_info& target_type() const = 0; |
| 308 #endif // _LIBCPP_NO_RTTI |
| 309 }; |
| 310 |
| 311 template<class _FD, class _Alloc, class _FB> class __func; |
| 312 |
| 313 template<class _Fp, class _Alloc, class _Rp> |
| 314 class __func<_Fp, _Alloc, _Rp()> |
| 315 : public __base<_Rp()> |
| 316 { |
| 317 __compressed_pair<_Fp, _Alloc> __f_; |
| 318 public: |
| 319 explicit __func(_Fp __f) : __f_(_VSTD::move(__f)) {} |
| 320 explicit __func(_Fp __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__
a)) {} |
| 321 virtual __base<_Rp()>* __clone() const; |
| 322 virtual void __clone(__base<_Rp()>*) const; |
| 323 virtual void destroy(); |
| 324 virtual void destroy_deallocate(); |
| 325 virtual _Rp operator()(); |
| 326 #ifndef _LIBCPP_NO_RTTI |
| 327 virtual const void* target(const type_info&) const; |
| 328 virtual const std::type_info& target_type() const; |
| 329 #endif // _LIBCPP_NO_RTTI |
| 330 }; |
| 331 |
| 332 template<class _Fp, class _Alloc, class _Rp> |
| 333 __base<_Rp()>* |
| 334 __func<_Fp, _Alloc, _Rp()>::__clone() const |
| 335 { |
| 336 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 337 _Ap __a(__f_.second()); |
| 338 typedef __allocator_destructor<_Ap> _Dp; |
| 339 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 340 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); |
| 341 return __hold.release(); |
| 342 } |
| 343 |
| 344 template<class _Fp, class _Alloc, class _Rp> |
| 345 void |
| 346 __func<_Fp, _Alloc, _Rp()>::__clone(__base<_Rp()>* __p) const |
| 347 { |
| 348 ::new (__p) __func(__f_.first(), __f_.second()); |
| 349 } |
| 350 |
| 351 template<class _Fp, class _Alloc, class _Rp> |
| 352 void |
| 353 __func<_Fp, _Alloc, _Rp()>::destroy() |
| 354 { |
| 355 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 356 } |
| 357 |
| 358 template<class _Fp, class _Alloc, class _Rp> |
| 359 void |
| 360 __func<_Fp, _Alloc, _Rp()>::destroy_deallocate() |
| 361 { |
| 362 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 363 _Ap __a(__f_.second()); |
| 364 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 365 __a.deallocate(this, 1); |
| 366 } |
| 367 |
| 368 template<class _Fp, class _Alloc, class _Rp> |
| 369 _Rp |
| 370 __func<_Fp, _Alloc, _Rp()>::operator()() |
| 371 { |
| 372 return __invoke(__f_.first()); |
| 373 } |
| 374 |
| 375 #ifndef _LIBCPP_NO_RTTI |
| 376 |
| 377 template<class _Fp, class _Alloc, class _Rp> |
| 378 const void* |
| 379 __func<_Fp, _Alloc, _Rp()>::target(const type_info& __ti) const |
| 380 { |
| 381 if (__ti == typeid(_Fp)) |
| 382 return &__f_.first(); |
| 383 return (const void*)0; |
| 384 } |
| 385 |
| 386 template<class _Fp, class _Alloc, class _Rp> |
| 387 const std::type_info& |
| 388 __func<_Fp, _Alloc, _Rp()>::target_type() const |
| 389 { |
| 390 return typeid(_Fp); |
| 391 } |
| 392 |
| 393 #endif // _LIBCPP_NO_RTTI |
| 394 |
| 395 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 396 class __func<_Fp, _Alloc, _Rp(_A0)> |
| 397 : public __base<_Rp(_A0)> |
| 398 { |
| 399 __compressed_pair<_Fp, _Alloc> __f_; |
| 400 public: |
| 401 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f))
{} |
| 402 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) |
| 403 : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} |
| 404 virtual __base<_Rp(_A0)>* __clone() const; |
| 405 virtual void __clone(__base<_Rp(_A0)>*) const; |
| 406 virtual void destroy(); |
| 407 virtual void destroy_deallocate(); |
| 408 virtual _Rp operator()(_A0); |
| 409 #ifndef _LIBCPP_NO_RTTI |
| 410 virtual const void* target(const type_info&) const; |
| 411 virtual const std::type_info& target_type() const; |
| 412 #endif // _LIBCPP_NO_RTTI |
| 413 }; |
| 414 |
| 415 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 416 __base<_Rp(_A0)>* |
| 417 __func<_Fp, _Alloc, _Rp(_A0)>::__clone() const |
| 418 { |
| 419 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 420 _Ap __a(__f_.second()); |
| 421 typedef __allocator_destructor<_Ap> _Dp; |
| 422 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 423 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); |
| 424 return __hold.release(); |
| 425 } |
| 426 |
| 427 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 428 void |
| 429 __func<_Fp, _Alloc, _Rp(_A0)>::__clone(__base<_Rp(_A0)>* __p) const |
| 430 { |
| 431 ::new (__p) __func(__f_.first(), __f_.second()); |
| 432 } |
| 433 |
| 434 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 435 void |
| 436 __func<_Fp, _Alloc, _Rp(_A0)>::destroy() |
| 437 { |
| 438 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 439 } |
| 440 |
| 441 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 442 void |
| 443 __func<_Fp, _Alloc, _Rp(_A0)>::destroy_deallocate() |
| 444 { |
| 445 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 446 _Ap __a(__f_.second()); |
| 447 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 448 __a.deallocate(this, 1); |
| 449 } |
| 450 |
| 451 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 452 _Rp |
| 453 __func<_Fp, _Alloc, _Rp(_A0)>::operator()(_A0 __a0) |
| 454 { |
| 455 return __invoke(__f_.first(), __a0); |
| 456 } |
| 457 |
| 458 #ifndef _LIBCPP_NO_RTTI |
| 459 |
| 460 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 461 const void* |
| 462 __func<_Fp, _Alloc, _Rp(_A0)>::target(const type_info& __ti) const |
| 463 { |
| 464 if (__ti == typeid(_Fp)) |
| 465 return &__f_.first(); |
| 466 return (const void*)0; |
| 467 } |
| 468 |
| 469 template<class _Fp, class _Alloc, class _Rp, class _A0> |
| 470 const std::type_info& |
| 471 __func<_Fp, _Alloc, _Rp(_A0)>::target_type() const |
| 472 { |
| 473 return typeid(_Fp); |
| 474 } |
| 475 |
| 476 #endif // _LIBCPP_NO_RTTI |
| 477 |
| 478 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 479 class __func<_Fp, _Alloc, _Rp(_A0, _A1)> |
| 480 : public __base<_Rp(_A0, _A1)> |
| 481 { |
| 482 __compressed_pair<_Fp, _Alloc> __f_; |
| 483 public: |
| 484 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f))
{} |
| 485 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) |
| 486 : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} |
| 487 virtual __base<_Rp(_A0, _A1)>* __clone() const; |
| 488 virtual void __clone(__base<_Rp(_A0, _A1)>*) const; |
| 489 virtual void destroy(); |
| 490 virtual void destroy_deallocate(); |
| 491 virtual _Rp operator()(_A0, _A1); |
| 492 #ifndef _LIBCPP_NO_RTTI |
| 493 virtual const void* target(const type_info&) const; |
| 494 virtual const std::type_info& target_type() const; |
| 495 #endif // _LIBCPP_NO_RTTI |
| 496 }; |
| 497 |
| 498 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 499 __base<_Rp(_A0, _A1)>* |
| 500 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone() const |
| 501 { |
| 502 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 503 _Ap __a(__f_.second()); |
| 504 typedef __allocator_destructor<_Ap> _Dp; |
| 505 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 506 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); |
| 507 return __hold.release(); |
| 508 } |
| 509 |
| 510 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 511 void |
| 512 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::__clone(__base<_Rp(_A0, _A1)>* __p) const |
| 513 { |
| 514 ::new (__p) __func(__f_.first(), __f_.second()); |
| 515 } |
| 516 |
| 517 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 518 void |
| 519 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy() |
| 520 { |
| 521 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 522 } |
| 523 |
| 524 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 525 void |
| 526 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::destroy_deallocate() |
| 527 { |
| 528 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 529 _Ap __a(__f_.second()); |
| 530 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 531 __a.deallocate(this, 1); |
| 532 } |
| 533 |
| 534 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 535 _Rp |
| 536 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) |
| 537 { |
| 538 return __invoke(__f_.first(), __a0, __a1); |
| 539 } |
| 540 |
| 541 #ifndef _LIBCPP_NO_RTTI |
| 542 |
| 543 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 544 const void* |
| 545 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target(const type_info& __ti) const |
| 546 { |
| 547 if (__ti == typeid(_Fp)) |
| 548 return &__f_.first(); |
| 549 return (const void*)0; |
| 550 } |
| 551 |
| 552 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1> |
| 553 const std::type_info& |
| 554 __func<_Fp, _Alloc, _Rp(_A0, _A1)>::target_type() const |
| 555 { |
| 556 return typeid(_Fp); |
| 557 } |
| 558 |
| 559 #endif // _LIBCPP_NO_RTTI |
| 560 |
| 561 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 562 class __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> |
| 563 : public __base<_Rp(_A0, _A1, _A2)> |
| 564 { |
| 565 __compressed_pair<_Fp, _Alloc> __f_; |
| 566 public: |
| 567 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f) : __f_(_VSTD::move(__f))
{} |
| 568 _LIBCPP_INLINE_VISIBILITY explicit __func(_Fp __f, _Alloc __a) |
| 569 : __f_(_VSTD::move(__f), _VSTD::move(__a)) {} |
| 570 virtual __base<_Rp(_A0, _A1, _A2)>* __clone() const; |
| 571 virtual void __clone(__base<_Rp(_A0, _A1, _A2)>*) const; |
| 572 virtual void destroy(); |
| 573 virtual void destroy_deallocate(); |
| 574 virtual _Rp operator()(_A0, _A1, _A2); |
| 575 #ifndef _LIBCPP_NO_RTTI |
| 576 virtual const void* target(const type_info&) const; |
| 577 virtual const std::type_info& target_type() const; |
| 578 #endif // _LIBCPP_NO_RTTI |
| 579 }; |
| 580 |
| 581 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 582 __base<_Rp(_A0, _A1, _A2)>* |
| 583 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone() const |
| 584 { |
| 585 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 586 _Ap __a(__f_.second()); |
| 587 typedef __allocator_destructor<_Ap> _Dp; |
| 588 unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 589 ::new (__hold.get()) __func(__f_.first(), _Alloc(__a)); |
| 590 return __hold.release(); |
| 591 } |
| 592 |
| 593 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 594 void |
| 595 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::__clone(__base<_Rp(_A0, _A1, _A2)>* __p
) const |
| 596 { |
| 597 ::new (__p) __func(__f_.first(), __f_.second()); |
| 598 } |
| 599 |
| 600 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 601 void |
| 602 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy() |
| 603 { |
| 604 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 605 } |
| 606 |
| 607 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 608 void |
| 609 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::destroy_deallocate() |
| 610 { |
| 611 typedef typename _Alloc::template rebind<__func>::other _Ap; |
| 612 _Ap __a(__f_.second()); |
| 613 __f_.~__compressed_pair<_Fp, _Alloc>(); |
| 614 __a.deallocate(this, 1); |
| 615 } |
| 616 |
| 617 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 618 _Rp |
| 619 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2
) |
| 620 { |
| 621 return __invoke(__f_.first(), __a0, __a1, __a2); |
| 622 } |
| 623 |
| 624 #ifndef _LIBCPP_NO_RTTI |
| 625 |
| 626 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 627 const void* |
| 628 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target(const type_info& __ti) const |
| 629 { |
| 630 if (__ti == typeid(_Fp)) |
| 631 return &__f_.first(); |
| 632 return (const void*)0; |
| 633 } |
| 634 |
| 635 template<class _Fp, class _Alloc, class _Rp, class _A0, class _A1, class _A2> |
| 636 const std::type_info& |
| 637 __func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)>::target_type() const |
| 638 { |
| 639 return typeid(_Fp); |
| 640 } |
| 641 |
| 642 #endif // _LIBCPP_NO_RTTI |
| 643 |
| 644 } // __function |
| 645 |
| 646 template<class _Rp> |
| 647 class _LIBCPP_TYPE_VIS_ONLY function<_Rp()> |
| 648 { |
| 649 typedef __function::__base<_Rp()> __base; |
| 650 aligned_storage<3*sizeof(void*)>::type __buf_; |
| 651 __base* __f_; |
| 652 |
| 653 template <class _Fp> |
| 654 static bool __not_null(const _Fp&) {return true;} |
| 655 template <class _R2> |
| 656 static bool __not_null(const function<_Rp()>& __p) {return __p;} |
| 657 public: |
| 658 typedef _Rp result_type; |
| 659 |
| 660 // 20.7.16.2.1, construct/copy/destroy: |
| 661 _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} |
| 662 _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} |
| 663 function(const function&); |
| 664 template<class _Fp> |
| 665 function(_Fp, |
| 666 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 667 |
| 668 template<class _Alloc> |
| 669 _LIBCPP_INLINE_VISIBILITY |
| 670 function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
| 671 template<class _Alloc> |
| 672 _LIBCPP_INLINE_VISIBILITY |
| 673 function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
| 674 template<class _Alloc> |
| 675 function(allocator_arg_t, const _Alloc&, const function&); |
| 676 template<class _Fp, class _Alloc> |
| 677 function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
| 678 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 679 |
| 680 function& operator=(const function&); |
| 681 function& operator=(nullptr_t); |
| 682 template<class _Fp> |
| 683 typename enable_if |
| 684 < |
| 685 !is_integral<_Fp>::value, |
| 686 function& |
| 687 >::type |
| 688 operator=(_Fp); |
| 689 |
| 690 ~function(); |
| 691 |
| 692 // 20.7.16.2.2, function modifiers: |
| 693 void swap(function&); |
| 694 template<class _Fp, class _Alloc> |
| 695 _LIBCPP_INLINE_VISIBILITY |
| 696 void assign(_Fp __f, const _Alloc& __a) |
| 697 {function(allocator_arg, __a, __f).swap(*this);} |
| 698 |
| 699 // 20.7.16.2.3, function capacity: |
| 700 _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} |
| 701 |
| 702 private: |
| 703 // deleted overloads close possible hole in the type system |
| 704 template<class _R2> |
| 705 bool operator==(const function<_R2()>&) const;// = delete; |
| 706 template<class _R2> |
| 707 bool operator!=(const function<_R2()>&) const;// = delete; |
| 708 public: |
| 709 // 20.7.16.2.4, function invocation: |
| 710 _Rp operator()() const; |
| 711 |
| 712 #ifndef _LIBCPP_NO_RTTI |
| 713 // 20.7.16.2.5, function target access: |
| 714 const std::type_info& target_type() const; |
| 715 template <typename _Tp> _Tp* target(); |
| 716 template <typename _Tp> const _Tp* target() const; |
| 717 #endif // _LIBCPP_NO_RTTI |
| 718 }; |
| 719 |
| 720 template<class _Rp> |
| 721 function<_Rp()>::function(const function& __f) |
| 722 { |
| 723 if (__f.__f_ == 0) |
| 724 __f_ = 0; |
| 725 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 726 { |
| 727 __f_ = (__base*)&__buf_; |
| 728 __f.__f_->__clone(__f_); |
| 729 } |
| 730 else |
| 731 __f_ = __f.__f_->__clone(); |
| 732 } |
| 733 |
| 734 template<class _Rp> |
| 735 template<class _Alloc> |
| 736 function<_Rp()>::function(allocator_arg_t, const _Alloc&, const function& __f) |
| 737 { |
| 738 if (__f.__f_ == 0) |
| 739 __f_ = 0; |
| 740 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 741 { |
| 742 __f_ = (__base*)&__buf_; |
| 743 __f.__f_->__clone(__f_); |
| 744 } |
| 745 else |
| 746 __f_ = __f.__f_->__clone(); |
| 747 } |
| 748 |
| 749 template<class _Rp> |
| 750 template <class _Fp> |
| 751 function<_Rp()>::function(_Fp __f, |
| 752 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 753 : __f_(0) |
| 754 { |
| 755 if (__not_null(__f)) |
| 756 { |
| 757 typedef __function::__func<_Fp, allocator<_Fp>, _Rp()> _FF; |
| 758 if (sizeof(_FF) <= sizeof(__buf_)) |
| 759 { |
| 760 __f_ = (__base*)&__buf_; |
| 761 ::new (__f_) _FF(__f); |
| 762 } |
| 763 else |
| 764 { |
| 765 typedef allocator<_FF> _Ap; |
| 766 _Ap __a; |
| 767 typedef __allocator_destructor<_Ap> _Dp; |
| 768 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 769 ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
| 770 __f_ = __hold.release(); |
| 771 } |
| 772 } |
| 773 } |
| 774 |
| 775 template<class _Rp> |
| 776 template <class _Fp, class _Alloc> |
| 777 function<_Rp()>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
| 778 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 779 : __f_(0) |
| 780 { |
| 781 typedef allocator_traits<_Alloc> __alloc_traits; |
| 782 if (__not_null(__f)) |
| 783 { |
| 784 typedef __function::__func<_Fp, _Alloc, _Rp()> _FF; |
| 785 if (sizeof(_FF) <= sizeof(__buf_)) |
| 786 { |
| 787 __f_ = (__base*)&__buf_; |
| 788 ::new (__f_) _FF(__f); |
| 789 } |
| 790 else |
| 791 { |
| 792 typedef typename __alloc_traits::template |
| 793 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES |
| 794 rebind_alloc<_FF> |
| 795 #else |
| 796 rebind_alloc<_FF>::other |
| 797 #endif |
| 798 _Ap; |
| 799 _Ap __a(__a0); |
| 800 typedef __allocator_destructor<_Ap> _Dp; |
| 801 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 802 ::new (__hold.get()) _FF(__f, _Alloc(__a)); |
| 803 __f_ = __hold.release(); |
| 804 } |
| 805 } |
| 806 } |
| 807 |
| 808 template<class _Rp> |
| 809 function<_Rp()>& |
| 810 function<_Rp()>::operator=(const function& __f) |
| 811 { |
| 812 function(__f).swap(*this); |
| 813 return *this; |
| 814 } |
| 815 |
| 816 template<class _Rp> |
| 817 function<_Rp()>& |
| 818 function<_Rp()>::operator=(nullptr_t) |
| 819 { |
| 820 if (__f_ == (__base*)&__buf_) |
| 821 __f_->destroy(); |
| 822 else if (__f_) |
| 823 __f_->destroy_deallocate(); |
| 824 __f_ = 0; |
| 825 } |
| 826 |
| 827 template<class _Rp> |
| 828 template <class _Fp> |
| 829 typename enable_if |
| 830 < |
| 831 !is_integral<_Fp>::value, |
| 832 function<_Rp()>& |
| 833 >::type |
| 834 function<_Rp()>::operator=(_Fp __f) |
| 835 { |
| 836 function(_VSTD::move(__f)).swap(*this); |
| 837 return *this; |
| 838 } |
| 839 |
| 840 template<class _Rp> |
| 841 function<_Rp()>::~function() |
| 842 { |
| 843 if (__f_ == (__base*)&__buf_) |
| 844 __f_->destroy(); |
| 845 else if (__f_) |
| 846 __f_->destroy_deallocate(); |
| 847 } |
| 848 |
| 849 template<class _Rp> |
| 850 void |
| 851 function<_Rp()>::swap(function& __f) |
| 852 { |
| 853 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
| 854 { |
| 855 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
| 856 __base* __t = (__base*)&__tempbuf; |
| 857 __f_->__clone(__t); |
| 858 __f_->destroy(); |
| 859 __f_ = 0; |
| 860 __f.__f_->__clone((__base*)&__buf_); |
| 861 __f.__f_->destroy(); |
| 862 __f.__f_ = 0; |
| 863 __f_ = (__base*)&__buf_; |
| 864 __t->__clone((__base*)&__f.__buf_); |
| 865 __t->destroy(); |
| 866 __f.__f_ = (__base*)&__f.__buf_; |
| 867 } |
| 868 else if (__f_ == (__base*)&__buf_) |
| 869 { |
| 870 __f_->__clone((__base*)&__f.__buf_); |
| 871 __f_->destroy(); |
| 872 __f_ = __f.__f_; |
| 873 __f.__f_ = (__base*)&__f.__buf_; |
| 874 } |
| 875 else if (__f.__f_ == (__base*)&__f.__buf_) |
| 876 { |
| 877 __f.__f_->__clone((__base*)&__buf_); |
| 878 __f.__f_->destroy(); |
| 879 __f.__f_ = __f_; |
| 880 __f_ = (__base*)&__buf_; |
| 881 } |
| 882 else |
| 883 _VSTD::swap(__f_, __f.__f_); |
| 884 } |
| 885 |
| 886 template<class _Rp> |
| 887 _Rp |
| 888 function<_Rp()>::operator()() const |
| 889 { |
| 890 #ifndef _LIBCPP_NO_EXCEPTIONS |
| 891 if (__f_ == 0) |
| 892 throw bad_function_call(); |
| 893 #endif // _LIBCPP_NO_EXCEPTIONS |
| 894 return (*__f_)(); |
| 895 } |
| 896 |
| 897 #ifndef _LIBCPP_NO_RTTI |
| 898 |
| 899 template<class _Rp> |
| 900 const std::type_info& |
| 901 function<_Rp()>::target_type() const |
| 902 { |
| 903 if (__f_ == 0) |
| 904 return typeid(void); |
| 905 return __f_->target_type(); |
| 906 } |
| 907 |
| 908 template<class _Rp> |
| 909 template <typename _Tp> |
| 910 _Tp* |
| 911 function<_Rp()>::target() |
| 912 { |
| 913 if (__f_ == 0) |
| 914 return (_Tp*)0; |
| 915 return (_Tp*)__f_->target(typeid(_Tp)); |
| 916 } |
| 917 |
| 918 template<class _Rp> |
| 919 template <typename _Tp> |
| 920 const _Tp* |
| 921 function<_Rp()>::target() const |
| 922 { |
| 923 if (__f_ == 0) |
| 924 return (const _Tp*)0; |
| 925 return (const _Tp*)__f_->target(typeid(_Tp)); |
| 926 } |
| 927 |
| 928 #endif // _LIBCPP_NO_RTTI |
| 929 |
| 930 template<class _Rp, class _A0> |
| 931 class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0)> |
| 932 : public unary_function<_A0, _Rp> |
| 933 { |
| 934 typedef __function::__base<_Rp(_A0)> __base; |
| 935 aligned_storage<3*sizeof(void*)>::type __buf_; |
| 936 __base* __f_; |
| 937 |
| 938 template <class _Fp> |
| 939 _LIBCPP_INLINE_VISIBILITY |
| 940 static bool __not_null(const _Fp&) {return true;} |
| 941 template <class _R2, class _B0> |
| 942 _LIBCPP_INLINE_VISIBILITY |
| 943 static bool __not_null(_R2 (*__p)(_B0)) {return __p;} |
| 944 template <class _R2, class _Cp> |
| 945 _LIBCPP_INLINE_VISIBILITY |
| 946 static bool __not_null(_R2 (_Cp::*__p)()) {return __p;} |
| 947 template <class _R2, class _Cp> |
| 948 _LIBCPP_INLINE_VISIBILITY |
| 949 static bool __not_null(_R2 (_Cp::*__p)() const) {return __p;} |
| 950 template <class _R2, class _Cp> |
| 951 _LIBCPP_INLINE_VISIBILITY |
| 952 static bool __not_null(_R2 (_Cp::*__p)() volatile) {return __p;} |
| 953 template <class _R2, class _Cp> |
| 954 _LIBCPP_INLINE_VISIBILITY |
| 955 static bool __not_null(_R2 (_Cp::*__p)() const volatile) {return __p;} |
| 956 template <class _R2, class _B0> |
| 957 _LIBCPP_INLINE_VISIBILITY |
| 958 static bool __not_null(const function<_Rp(_B0)>& __p) {return __p;} |
| 959 public: |
| 960 typedef _Rp result_type; |
| 961 |
| 962 // 20.7.16.2.1, construct/copy/destroy: |
| 963 _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} |
| 964 _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} |
| 965 function(const function&); |
| 966 template<class _Fp> |
| 967 function(_Fp, |
| 968 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 969 |
| 970 template<class _Alloc> |
| 971 _LIBCPP_INLINE_VISIBILITY |
| 972 function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
| 973 template<class _Alloc> |
| 974 _LIBCPP_INLINE_VISIBILITY |
| 975 function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
| 976 template<class _Alloc> |
| 977 function(allocator_arg_t, const _Alloc&, const function&); |
| 978 template<class _Fp, class _Alloc> |
| 979 function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
| 980 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 981 |
| 982 function& operator=(const function&); |
| 983 function& operator=(nullptr_t); |
| 984 template<class _Fp> |
| 985 typename enable_if |
| 986 < |
| 987 !is_integral<_Fp>::value, |
| 988 function& |
| 989 >::type |
| 990 operator=(_Fp); |
| 991 |
| 992 ~function(); |
| 993 |
| 994 // 20.7.16.2.2, function modifiers: |
| 995 void swap(function&); |
| 996 template<class _Fp, class _Alloc> |
| 997 _LIBCPP_INLINE_VISIBILITY |
| 998 void assign(_Fp __f, const _Alloc& __a) |
| 999 {function(allocator_arg, __a, __f).swap(*this);} |
| 1000 |
| 1001 // 20.7.16.2.3, function capacity: |
| 1002 _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} |
| 1003 |
| 1004 private: |
| 1005 // deleted overloads close possible hole in the type system |
| 1006 template<class _R2, class _B0> |
| 1007 bool operator==(const function<_R2(_B0)>&) const;// = delete; |
| 1008 template<class _R2, class _B0> |
| 1009 bool operator!=(const function<_R2(_B0)>&) const;// = delete; |
| 1010 public: |
| 1011 // 20.7.16.2.4, function invocation: |
| 1012 _Rp operator()(_A0) const; |
| 1013 |
| 1014 #ifndef _LIBCPP_NO_RTTI |
| 1015 // 20.7.16.2.5, function target access: |
| 1016 const std::type_info& target_type() const; |
| 1017 template <typename _Tp> _Tp* target(); |
| 1018 template <typename _Tp> const _Tp* target() const; |
| 1019 #endif // _LIBCPP_NO_RTTI |
| 1020 }; |
| 1021 |
| 1022 template<class _Rp, class _A0> |
| 1023 function<_Rp(_A0)>::function(const function& __f) |
| 1024 { |
| 1025 if (__f.__f_ == 0) |
| 1026 __f_ = 0; |
| 1027 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1028 { |
| 1029 __f_ = (__base*)&__buf_; |
| 1030 __f.__f_->__clone(__f_); |
| 1031 } |
| 1032 else |
| 1033 __f_ = __f.__f_->__clone(); |
| 1034 } |
| 1035 |
| 1036 template<class _Rp, class _A0> |
| 1037 template<class _Alloc> |
| 1038 function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc&, const function& __f
) |
| 1039 { |
| 1040 if (__f.__f_ == 0) |
| 1041 __f_ = 0; |
| 1042 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1043 { |
| 1044 __f_ = (__base*)&__buf_; |
| 1045 __f.__f_->__clone(__f_); |
| 1046 } |
| 1047 else |
| 1048 __f_ = __f.__f_->__clone(); |
| 1049 } |
| 1050 |
| 1051 template<class _Rp, class _A0> |
| 1052 template <class _Fp> |
| 1053 function<_Rp(_A0)>::function(_Fp __f, |
| 1054 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 1055 : __f_(0) |
| 1056 { |
| 1057 if (__not_null(__f)) |
| 1058 { |
| 1059 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0)> _FF; |
| 1060 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1061 { |
| 1062 __f_ = (__base*)&__buf_; |
| 1063 ::new (__f_) _FF(__f); |
| 1064 } |
| 1065 else |
| 1066 { |
| 1067 typedef allocator<_FF> _Ap; |
| 1068 _Ap __a; |
| 1069 typedef __allocator_destructor<_Ap> _Dp; |
| 1070 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1071 ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
| 1072 __f_ = __hold.release(); |
| 1073 } |
| 1074 } |
| 1075 } |
| 1076 |
| 1077 template<class _Rp, class _A0> |
| 1078 template <class _Fp, class _Alloc> |
| 1079 function<_Rp(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
| 1080 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 1081 : __f_(0) |
| 1082 { |
| 1083 typedef allocator_traits<_Alloc> __alloc_traits; |
| 1084 if (__not_null(__f)) |
| 1085 { |
| 1086 typedef __function::__func<_Fp, _Alloc, _Rp(_A0)> _FF; |
| 1087 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1088 { |
| 1089 __f_ = (__base*)&__buf_; |
| 1090 ::new (__f_) _FF(__f); |
| 1091 } |
| 1092 else |
| 1093 { |
| 1094 typedef typename __alloc_traits::template |
| 1095 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES |
| 1096 rebind_alloc<_FF> |
| 1097 #else |
| 1098 rebind_alloc<_FF>::other |
| 1099 #endif |
| 1100 _Ap; |
| 1101 _Ap __a(__a0); |
| 1102 typedef __allocator_destructor<_Ap> _Dp; |
| 1103 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1104 ::new (__hold.get()) _FF(__f, _Alloc(__a)); |
| 1105 __f_ = __hold.release(); |
| 1106 } |
| 1107 } |
| 1108 } |
| 1109 |
| 1110 template<class _Rp, class _A0> |
| 1111 function<_Rp(_A0)>& |
| 1112 function<_Rp(_A0)>::operator=(const function& __f) |
| 1113 { |
| 1114 function(__f).swap(*this); |
| 1115 return *this; |
| 1116 } |
| 1117 |
| 1118 template<class _Rp, class _A0> |
| 1119 function<_Rp(_A0)>& |
| 1120 function<_Rp(_A0)>::operator=(nullptr_t) |
| 1121 { |
| 1122 if (__f_ == (__base*)&__buf_) |
| 1123 __f_->destroy(); |
| 1124 else if (__f_) |
| 1125 __f_->destroy_deallocate(); |
| 1126 __f_ = 0; |
| 1127 } |
| 1128 |
| 1129 template<class _Rp, class _A0> |
| 1130 template <class _Fp> |
| 1131 typename enable_if |
| 1132 < |
| 1133 !is_integral<_Fp>::value, |
| 1134 function<_Rp(_A0)>& |
| 1135 >::type |
| 1136 function<_Rp(_A0)>::operator=(_Fp __f) |
| 1137 { |
| 1138 function(_VSTD::move(__f)).swap(*this); |
| 1139 return *this; |
| 1140 } |
| 1141 |
| 1142 template<class _Rp, class _A0> |
| 1143 function<_Rp(_A0)>::~function() |
| 1144 { |
| 1145 if (__f_ == (__base*)&__buf_) |
| 1146 __f_->destroy(); |
| 1147 else if (__f_) |
| 1148 __f_->destroy_deallocate(); |
| 1149 } |
| 1150 |
| 1151 template<class _Rp, class _A0> |
| 1152 void |
| 1153 function<_Rp(_A0)>::swap(function& __f) |
| 1154 { |
| 1155 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
| 1156 { |
| 1157 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
| 1158 __base* __t = (__base*)&__tempbuf; |
| 1159 __f_->__clone(__t); |
| 1160 __f_->destroy(); |
| 1161 __f_ = 0; |
| 1162 __f.__f_->__clone((__base*)&__buf_); |
| 1163 __f.__f_->destroy(); |
| 1164 __f.__f_ = 0; |
| 1165 __f_ = (__base*)&__buf_; |
| 1166 __t->__clone((__base*)&__f.__buf_); |
| 1167 __t->destroy(); |
| 1168 __f.__f_ = (__base*)&__f.__buf_; |
| 1169 } |
| 1170 else if (__f_ == (__base*)&__buf_) |
| 1171 { |
| 1172 __f_->__clone((__base*)&__f.__buf_); |
| 1173 __f_->destroy(); |
| 1174 __f_ = __f.__f_; |
| 1175 __f.__f_ = (__base*)&__f.__buf_; |
| 1176 } |
| 1177 else if (__f.__f_ == (__base*)&__f.__buf_) |
| 1178 { |
| 1179 __f.__f_->__clone((__base*)&__buf_); |
| 1180 __f.__f_->destroy(); |
| 1181 __f.__f_ = __f_; |
| 1182 __f_ = (__base*)&__buf_; |
| 1183 } |
| 1184 else |
| 1185 _VSTD::swap(__f_, __f.__f_); |
| 1186 } |
| 1187 |
| 1188 template<class _Rp, class _A0> |
| 1189 _Rp |
| 1190 function<_Rp(_A0)>::operator()(_A0 __a0) const |
| 1191 { |
| 1192 #ifndef _LIBCPP_NO_EXCEPTIONS |
| 1193 if (__f_ == 0) |
| 1194 throw bad_function_call(); |
| 1195 #endif // _LIBCPP_NO_EXCEPTIONS |
| 1196 return (*__f_)(__a0); |
| 1197 } |
| 1198 |
| 1199 #ifndef _LIBCPP_NO_RTTI |
| 1200 |
| 1201 template<class _Rp, class _A0> |
| 1202 const std::type_info& |
| 1203 function<_Rp(_A0)>::target_type() const |
| 1204 { |
| 1205 if (__f_ == 0) |
| 1206 return typeid(void); |
| 1207 return __f_->target_type(); |
| 1208 } |
| 1209 |
| 1210 template<class _Rp, class _A0> |
| 1211 template <typename _Tp> |
| 1212 _Tp* |
| 1213 function<_Rp(_A0)>::target() |
| 1214 { |
| 1215 if (__f_ == 0) |
| 1216 return (_Tp*)0; |
| 1217 return (_Tp*)__f_->target(typeid(_Tp)); |
| 1218 } |
| 1219 |
| 1220 template<class _Rp, class _A0> |
| 1221 template <typename _Tp> |
| 1222 const _Tp* |
| 1223 function<_Rp(_A0)>::target() const |
| 1224 { |
| 1225 if (__f_ == 0) |
| 1226 return (const _Tp*)0; |
| 1227 return (const _Tp*)__f_->target(typeid(_Tp)); |
| 1228 } |
| 1229 |
| 1230 #endif // _LIBCPP_NO_RTTI |
| 1231 |
| 1232 template<class _Rp, class _A0, class _A1> |
| 1233 class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1)> |
| 1234 : public binary_function<_A0, _A1, _Rp> |
| 1235 { |
| 1236 typedef __function::__base<_Rp(_A0, _A1)> __base; |
| 1237 aligned_storage<3*sizeof(void*)>::type __buf_; |
| 1238 __base* __f_; |
| 1239 |
| 1240 template <class _Fp> |
| 1241 _LIBCPP_INLINE_VISIBILITY |
| 1242 static bool __not_null(const _Fp&) {return true;} |
| 1243 template <class _R2, class _B0, class _B1> |
| 1244 _LIBCPP_INLINE_VISIBILITY |
| 1245 static bool __not_null(_R2 (*__p)(_B0, _B1)) {return __p;} |
| 1246 template <class _R2, class _Cp, class _B1> |
| 1247 _LIBCPP_INLINE_VISIBILITY |
| 1248 static bool __not_null(_R2 (_Cp::*__p)(_B1)) {return __p;} |
| 1249 template <class _R2, class _Cp, class _B1> |
| 1250 _LIBCPP_INLINE_VISIBILITY |
| 1251 static bool __not_null(_R2 (_Cp::*__p)(_B1) const) {return __p;} |
| 1252 template <class _R2, class _Cp, class _B1> |
| 1253 _LIBCPP_INLINE_VISIBILITY |
| 1254 static bool __not_null(_R2 (_Cp::*__p)(_B1) volatile) {return __p;} |
| 1255 template <class _R2, class _Cp, class _B1> |
| 1256 _LIBCPP_INLINE_VISIBILITY |
| 1257 static bool __not_null(_R2 (_Cp::*__p)(_B1) const volatile) {return __p;
} |
| 1258 template <class _R2, class _B0, class _B1> |
| 1259 _LIBCPP_INLINE_VISIBILITY |
| 1260 static bool __not_null(const function<_Rp(_B0, _B1)>& __p) {return __p;} |
| 1261 public: |
| 1262 typedef _Rp result_type; |
| 1263 |
| 1264 // 20.7.16.2.1, construct/copy/destroy: |
| 1265 _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} |
| 1266 _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} |
| 1267 function(const function&); |
| 1268 template<class _Fp> |
| 1269 function(_Fp, |
| 1270 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 1271 |
| 1272 template<class _Alloc> |
| 1273 _LIBCPP_INLINE_VISIBILITY |
| 1274 function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
| 1275 template<class _Alloc> |
| 1276 _LIBCPP_INLINE_VISIBILITY |
| 1277 function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
| 1278 template<class _Alloc> |
| 1279 function(allocator_arg_t, const _Alloc&, const function&); |
| 1280 template<class _Fp, class _Alloc> |
| 1281 function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
| 1282 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 1283 |
| 1284 function& operator=(const function&); |
| 1285 function& operator=(nullptr_t); |
| 1286 template<class _Fp> |
| 1287 typename enable_if |
| 1288 < |
| 1289 !is_integral<_Fp>::value, |
| 1290 function& |
| 1291 >::type |
| 1292 operator=(_Fp); |
| 1293 |
| 1294 ~function(); |
| 1295 |
| 1296 // 20.7.16.2.2, function modifiers: |
| 1297 void swap(function&); |
| 1298 template<class _Fp, class _Alloc> |
| 1299 _LIBCPP_INLINE_VISIBILITY |
| 1300 void assign(_Fp __f, const _Alloc& __a) |
| 1301 {function(allocator_arg, __a, __f).swap(*this);} |
| 1302 |
| 1303 // 20.7.16.2.3, function capacity: |
| 1304 operator bool() const {return __f_;} |
| 1305 |
| 1306 private: |
| 1307 // deleted overloads close possible hole in the type system |
| 1308 template<class _R2, class _B0, class _B1> |
| 1309 bool operator==(const function<_R2(_B0, _B1)>&) const;// = delete; |
| 1310 template<class _R2, class _B0, class _B1> |
| 1311 bool operator!=(const function<_R2(_B0, _B1)>&) const;// = delete; |
| 1312 public: |
| 1313 // 20.7.16.2.4, function invocation: |
| 1314 _Rp operator()(_A0, _A1) const; |
| 1315 |
| 1316 #ifndef _LIBCPP_NO_RTTI |
| 1317 // 20.7.16.2.5, function target access: |
| 1318 const std::type_info& target_type() const; |
| 1319 template <typename _Tp> _Tp* target(); |
| 1320 template <typename _Tp> const _Tp* target() const; |
| 1321 #endif // _LIBCPP_NO_RTTI |
| 1322 }; |
| 1323 |
| 1324 template<class _Rp, class _A0, class _A1> |
| 1325 function<_Rp(_A0, _A1)>::function(const function& __f) |
| 1326 { |
| 1327 if (__f.__f_ == 0) |
| 1328 __f_ = 0; |
| 1329 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1330 { |
| 1331 __f_ = (__base*)&__buf_; |
| 1332 __f.__f_->__clone(__f_); |
| 1333 } |
| 1334 else |
| 1335 __f_ = __f.__f_->__clone(); |
| 1336 } |
| 1337 |
| 1338 template<class _Rp, class _A0, class _A1> |
| 1339 template<class _Alloc> |
| 1340 function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc&, const function
& __f) |
| 1341 { |
| 1342 if (__f.__f_ == 0) |
| 1343 __f_ = 0; |
| 1344 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1345 { |
| 1346 __f_ = (__base*)&__buf_; |
| 1347 __f.__f_->__clone(__f_); |
| 1348 } |
| 1349 else |
| 1350 __f_ = __f.__f_->__clone(); |
| 1351 } |
| 1352 |
| 1353 template<class _Rp, class _A0, class _A1> |
| 1354 template <class _Fp> |
| 1355 function<_Rp(_A0, _A1)>::function(_Fp __f, |
| 1356 typename enable_if<!is_integral<_Fp>::value>::t
ype*) |
| 1357 : __f_(0) |
| 1358 { |
| 1359 if (__not_null(__f)) |
| 1360 { |
| 1361 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1)> _FF; |
| 1362 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1363 { |
| 1364 __f_ = (__base*)&__buf_; |
| 1365 ::new (__f_) _FF(__f); |
| 1366 } |
| 1367 else |
| 1368 { |
| 1369 typedef allocator<_FF> _Ap; |
| 1370 _Ap __a; |
| 1371 typedef __allocator_destructor<_Ap> _Dp; |
| 1372 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1373 ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
| 1374 __f_ = __hold.release(); |
| 1375 } |
| 1376 } |
| 1377 } |
| 1378 |
| 1379 template<class _Rp, class _A0, class _A1> |
| 1380 template <class _Fp, class _Alloc> |
| 1381 function<_Rp(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f, |
| 1382 typename enable_if<!is_integral<_Fp>::value>::t
ype*) |
| 1383 : __f_(0) |
| 1384 { |
| 1385 typedef allocator_traits<_Alloc> __alloc_traits; |
| 1386 if (__not_null(__f)) |
| 1387 { |
| 1388 typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1)> _FF; |
| 1389 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1390 { |
| 1391 __f_ = (__base*)&__buf_; |
| 1392 ::new (__f_) _FF(__f); |
| 1393 } |
| 1394 else |
| 1395 { |
| 1396 typedef typename __alloc_traits::template |
| 1397 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES |
| 1398 rebind_alloc<_FF> |
| 1399 #else |
| 1400 rebind_alloc<_FF>::other |
| 1401 #endif |
| 1402 _Ap; |
| 1403 _Ap __a(__a0); |
| 1404 typedef __allocator_destructor<_Ap> _Dp; |
| 1405 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1406 ::new (__hold.get()) _FF(__f, _Alloc(__a)); |
| 1407 __f_ = __hold.release(); |
| 1408 } |
| 1409 } |
| 1410 } |
| 1411 |
| 1412 template<class _Rp, class _A0, class _A1> |
| 1413 function<_Rp(_A0, _A1)>& |
| 1414 function<_Rp(_A0, _A1)>::operator=(const function& __f) |
| 1415 { |
| 1416 function(__f).swap(*this); |
| 1417 return *this; |
| 1418 } |
| 1419 |
| 1420 template<class _Rp, class _A0, class _A1> |
| 1421 function<_Rp(_A0, _A1)>& |
| 1422 function<_Rp(_A0, _A1)>::operator=(nullptr_t) |
| 1423 { |
| 1424 if (__f_ == (__base*)&__buf_) |
| 1425 __f_->destroy(); |
| 1426 else if (__f_) |
| 1427 __f_->destroy_deallocate(); |
| 1428 __f_ = 0; |
| 1429 } |
| 1430 |
| 1431 template<class _Rp, class _A0, class _A1> |
| 1432 template <class _Fp> |
| 1433 typename enable_if |
| 1434 < |
| 1435 !is_integral<_Fp>::value, |
| 1436 function<_Rp(_A0, _A1)>& |
| 1437 >::type |
| 1438 function<_Rp(_A0, _A1)>::operator=(_Fp __f) |
| 1439 { |
| 1440 function(_VSTD::move(__f)).swap(*this); |
| 1441 return *this; |
| 1442 } |
| 1443 |
| 1444 template<class _Rp, class _A0, class _A1> |
| 1445 function<_Rp(_A0, _A1)>::~function() |
| 1446 { |
| 1447 if (__f_ == (__base*)&__buf_) |
| 1448 __f_->destroy(); |
| 1449 else if (__f_) |
| 1450 __f_->destroy_deallocate(); |
| 1451 } |
| 1452 |
| 1453 template<class _Rp, class _A0, class _A1> |
| 1454 void |
| 1455 function<_Rp(_A0, _A1)>::swap(function& __f) |
| 1456 { |
| 1457 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
| 1458 { |
| 1459 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
| 1460 __base* __t = (__base*)&__tempbuf; |
| 1461 __f_->__clone(__t); |
| 1462 __f_->destroy(); |
| 1463 __f_ = 0; |
| 1464 __f.__f_->__clone((__base*)&__buf_); |
| 1465 __f.__f_->destroy(); |
| 1466 __f.__f_ = 0; |
| 1467 __f_ = (__base*)&__buf_; |
| 1468 __t->__clone((__base*)&__f.__buf_); |
| 1469 __t->destroy(); |
| 1470 __f.__f_ = (__base*)&__f.__buf_; |
| 1471 } |
| 1472 else if (__f_ == (__base*)&__buf_) |
| 1473 { |
| 1474 __f_->__clone((__base*)&__f.__buf_); |
| 1475 __f_->destroy(); |
| 1476 __f_ = __f.__f_; |
| 1477 __f.__f_ = (__base*)&__f.__buf_; |
| 1478 } |
| 1479 else if (__f.__f_ == (__base*)&__f.__buf_) |
| 1480 { |
| 1481 __f.__f_->__clone((__base*)&__buf_); |
| 1482 __f.__f_->destroy(); |
| 1483 __f.__f_ = __f_; |
| 1484 __f_ = (__base*)&__buf_; |
| 1485 } |
| 1486 else |
| 1487 _VSTD::swap(__f_, __f.__f_); |
| 1488 } |
| 1489 |
| 1490 template<class _Rp, class _A0, class _A1> |
| 1491 _Rp |
| 1492 function<_Rp(_A0, _A1)>::operator()(_A0 __a0, _A1 __a1) const |
| 1493 { |
| 1494 #ifndef _LIBCPP_NO_EXCEPTIONS |
| 1495 if (__f_ == 0) |
| 1496 throw bad_function_call(); |
| 1497 #endif // _LIBCPP_NO_EXCEPTIONS |
| 1498 return (*__f_)(__a0, __a1); |
| 1499 } |
| 1500 |
| 1501 #ifndef _LIBCPP_NO_RTTI |
| 1502 |
| 1503 template<class _Rp, class _A0, class _A1> |
| 1504 const std::type_info& |
| 1505 function<_Rp(_A0, _A1)>::target_type() const |
| 1506 { |
| 1507 if (__f_ == 0) |
| 1508 return typeid(void); |
| 1509 return __f_->target_type(); |
| 1510 } |
| 1511 |
| 1512 template<class _Rp, class _A0, class _A1> |
| 1513 template <typename _Tp> |
| 1514 _Tp* |
| 1515 function<_Rp(_A0, _A1)>::target() |
| 1516 { |
| 1517 if (__f_ == 0) |
| 1518 return (_Tp*)0; |
| 1519 return (_Tp*)__f_->target(typeid(_Tp)); |
| 1520 } |
| 1521 |
| 1522 template<class _Rp, class _A0, class _A1> |
| 1523 template <typename _Tp> |
| 1524 const _Tp* |
| 1525 function<_Rp(_A0, _A1)>::target() const |
| 1526 { |
| 1527 if (__f_ == 0) |
| 1528 return (const _Tp*)0; |
| 1529 return (const _Tp*)__f_->target(typeid(_Tp)); |
| 1530 } |
| 1531 |
| 1532 #endif // _LIBCPP_NO_RTTI |
| 1533 |
| 1534 template<class _Rp, class _A0, class _A1, class _A2> |
| 1535 class _LIBCPP_TYPE_VIS_ONLY function<_Rp(_A0, _A1, _A2)> |
| 1536 { |
| 1537 typedef __function::__base<_Rp(_A0, _A1, _A2)> __base; |
| 1538 aligned_storage<3*sizeof(void*)>::type __buf_; |
| 1539 __base* __f_; |
| 1540 |
| 1541 template <class _Fp> |
| 1542 _LIBCPP_INLINE_VISIBILITY |
| 1543 static bool __not_null(const _Fp&) {return true;} |
| 1544 template <class _R2, class _B0, class _B1, class _B2> |
| 1545 _LIBCPP_INLINE_VISIBILITY |
| 1546 static bool __not_null(_R2 (*__p)(_B0, _B1, _B2)) {return __p;} |
| 1547 template <class _R2, class _Cp, class _B1, class _B2> |
| 1548 _LIBCPP_INLINE_VISIBILITY |
| 1549 static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2)) {return __p;} |
| 1550 template <class _R2, class _Cp, class _B1, class _B2> |
| 1551 _LIBCPP_INLINE_VISIBILITY |
| 1552 static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const) {return __p;} |
| 1553 template <class _R2, class _Cp, class _B1, class _B2> |
| 1554 _LIBCPP_INLINE_VISIBILITY |
| 1555 static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) volatile) {return __p;} |
| 1556 template <class _R2, class _Cp, class _B1, class _B2> |
| 1557 _LIBCPP_INLINE_VISIBILITY |
| 1558 static bool __not_null(_R2 (_Cp::*__p)(_B1, _B2) const volatile) {return
__p;} |
| 1559 template <class _R2, class _B0, class _B1, class _B2> |
| 1560 _LIBCPP_INLINE_VISIBILITY |
| 1561 static bool __not_null(const function<_Rp(_B0, _B1, _B2)>& __p) {return
__p;} |
| 1562 public: |
| 1563 typedef _Rp result_type; |
| 1564 |
| 1565 // 20.7.16.2.1, construct/copy/destroy: |
| 1566 _LIBCPP_INLINE_VISIBILITY explicit function() : __f_(0) {} |
| 1567 _LIBCPP_INLINE_VISIBILITY function(nullptr_t) : __f_(0) {} |
| 1568 function(const function&); |
| 1569 template<class _Fp> |
| 1570 function(_Fp, |
| 1571 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 1572 |
| 1573 template<class _Alloc> |
| 1574 _LIBCPP_INLINE_VISIBILITY |
| 1575 function(allocator_arg_t, const _Alloc&) : __f_(0) {} |
| 1576 template<class _Alloc> |
| 1577 _LIBCPP_INLINE_VISIBILITY |
| 1578 function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {} |
| 1579 template<class _Alloc> |
| 1580 function(allocator_arg_t, const _Alloc&, const function&); |
| 1581 template<class _Fp, class _Alloc> |
| 1582 function(allocator_arg_t, const _Alloc& __a, _Fp __f, |
| 1583 typename enable_if<!is_integral<_Fp>::value>::type* = 0); |
| 1584 |
| 1585 function& operator=(const function&); |
| 1586 function& operator=(nullptr_t); |
| 1587 template<class _Fp> |
| 1588 typename enable_if |
| 1589 < |
| 1590 !is_integral<_Fp>::value, |
| 1591 function& |
| 1592 >::type |
| 1593 operator=(_Fp); |
| 1594 |
| 1595 ~function(); |
| 1596 |
| 1597 // 20.7.16.2.2, function modifiers: |
| 1598 void swap(function&); |
| 1599 template<class _Fp, class _Alloc> |
| 1600 _LIBCPP_INLINE_VISIBILITY |
| 1601 void assign(_Fp __f, const _Alloc& __a) |
| 1602 {function(allocator_arg, __a, __f).swap(*this);} |
| 1603 |
| 1604 // 20.7.16.2.3, function capacity: |
| 1605 _LIBCPP_INLINE_VISIBILITY operator bool() const {return __f_;} |
| 1606 |
| 1607 private: |
| 1608 // deleted overloads close possible hole in the type system |
| 1609 template<class _R2, class _B0, class _B1, class _B2> |
| 1610 bool operator==(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; |
| 1611 template<class _R2, class _B0, class _B1, class _B2> |
| 1612 bool operator!=(const function<_R2(_B0, _B1, _B2)>&) const;// = delete; |
| 1613 public: |
| 1614 // 20.7.16.2.4, function invocation: |
| 1615 _Rp operator()(_A0, _A1, _A2) const; |
| 1616 |
| 1617 #ifndef _LIBCPP_NO_RTTI |
| 1618 // 20.7.16.2.5, function target access: |
| 1619 const std::type_info& target_type() const; |
| 1620 template <typename _Tp> _Tp* target(); |
| 1621 template <typename _Tp> const _Tp* target() const; |
| 1622 #endif // _LIBCPP_NO_RTTI |
| 1623 }; |
| 1624 |
| 1625 template<class _Rp, class _A0, class _A1, class _A2> |
| 1626 function<_Rp(_A0, _A1, _A2)>::function(const function& __f) |
| 1627 { |
| 1628 if (__f.__f_ == 0) |
| 1629 __f_ = 0; |
| 1630 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1631 { |
| 1632 __f_ = (__base*)&__buf_; |
| 1633 __f.__f_->__clone(__f_); |
| 1634 } |
| 1635 else |
| 1636 __f_ = __f.__f_->__clone(); |
| 1637 } |
| 1638 |
| 1639 template<class _Rp, class _A0, class _A1, class _A2> |
| 1640 template<class _Alloc> |
| 1641 function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc&, |
| 1642 const function& __f) |
| 1643 { |
| 1644 if (__f.__f_ == 0) |
| 1645 __f_ = 0; |
| 1646 else if (__f.__f_ == (const __base*)&__f.__buf_) |
| 1647 { |
| 1648 __f_ = (__base*)&__buf_; |
| 1649 __f.__f_->__clone(__f_); |
| 1650 } |
| 1651 else |
| 1652 __f_ = __f.__f_->__clone(); |
| 1653 } |
| 1654 |
| 1655 template<class _Rp, class _A0, class _A1, class _A2> |
| 1656 template <class _Fp> |
| 1657 function<_Rp(_A0, _A1, _A2)>::function(_Fp __f, |
| 1658 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 1659 : __f_(0) |
| 1660 { |
| 1661 if (__not_null(__f)) |
| 1662 { |
| 1663 typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_A0, _A1, _A2)> _FF; |
| 1664 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1665 { |
| 1666 __f_ = (__base*)&__buf_; |
| 1667 ::new (__f_) _FF(__f); |
| 1668 } |
| 1669 else |
| 1670 { |
| 1671 typedef allocator<_FF> _Ap; |
| 1672 _Ap __a; |
| 1673 typedef __allocator_destructor<_Ap> _Dp; |
| 1674 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1675 ::new (__hold.get()) _FF(__f, allocator<_Fp>(__a)); |
| 1676 __f_ = __hold.release(); |
| 1677 } |
| 1678 } |
| 1679 } |
| 1680 |
| 1681 template<class _Rp, class _A0, class _A1, class _A2> |
| 1682 template <class _Fp, class _Alloc> |
| 1683 function<_Rp(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _Fp
__f, |
| 1684 typename enable_if<!is_integral<_Fp>::value
>::type*) |
| 1685 : __f_(0) |
| 1686 { |
| 1687 typedef allocator_traits<_Alloc> __alloc_traits; |
| 1688 if (__not_null(__f)) |
| 1689 { |
| 1690 typedef __function::__func<_Fp, _Alloc, _Rp(_A0, _A1, _A2)> _FF; |
| 1691 if (sizeof(_FF) <= sizeof(__buf_)) |
| 1692 { |
| 1693 __f_ = (__base*)&__buf_; |
| 1694 ::new (__f_) _FF(__f); |
| 1695 } |
| 1696 else |
| 1697 { |
| 1698 typedef typename __alloc_traits::template |
| 1699 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES |
| 1700 rebind_alloc<_FF> |
| 1701 #else |
| 1702 rebind_alloc<_FF>::other |
| 1703 #endif |
| 1704 _Ap; |
| 1705 _Ap __a(__a0); |
| 1706 typedef __allocator_destructor<_Ap> _Dp; |
| 1707 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); |
| 1708 ::new (__hold.get()) _FF(__f, _Alloc(__a)); |
| 1709 __f_ = __hold.release(); |
| 1710 } |
| 1711 } |
| 1712 } |
| 1713 |
| 1714 template<class _Rp, class _A0, class _A1, class _A2> |
| 1715 function<_Rp(_A0, _A1, _A2)>& |
| 1716 function<_Rp(_A0, _A1, _A2)>::operator=(const function& __f) |
| 1717 { |
| 1718 function(__f).swap(*this); |
| 1719 return *this; |
| 1720 } |
| 1721 |
| 1722 template<class _Rp, class _A0, class _A1, class _A2> |
| 1723 function<_Rp(_A0, _A1, _A2)>& |
| 1724 function<_Rp(_A0, _A1, _A2)>::operator=(nullptr_t) |
| 1725 { |
| 1726 if (__f_ == (__base*)&__buf_) |
| 1727 __f_->destroy(); |
| 1728 else if (__f_) |
| 1729 __f_->destroy_deallocate(); |
| 1730 __f_ = 0; |
| 1731 } |
| 1732 |
| 1733 template<class _Rp, class _A0, class _A1, class _A2> |
| 1734 template <class _Fp> |
| 1735 typename enable_if |
| 1736 < |
| 1737 !is_integral<_Fp>::value, |
| 1738 function<_Rp(_A0, _A1, _A2)>& |
| 1739 >::type |
| 1740 function<_Rp(_A0, _A1, _A2)>::operator=(_Fp __f) |
| 1741 { |
| 1742 function(_VSTD::move(__f)).swap(*this); |
| 1743 return *this; |
| 1744 } |
| 1745 |
| 1746 template<class _Rp, class _A0, class _A1, class _A2> |
| 1747 function<_Rp(_A0, _A1, _A2)>::~function() |
| 1748 { |
| 1749 if (__f_ == (__base*)&__buf_) |
| 1750 __f_->destroy(); |
| 1751 else if (__f_) |
| 1752 __f_->destroy_deallocate(); |
| 1753 } |
| 1754 |
| 1755 template<class _Rp, class _A0, class _A1, class _A2> |
| 1756 void |
| 1757 function<_Rp(_A0, _A1, _A2)>::swap(function& __f) |
| 1758 { |
| 1759 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) |
| 1760 { |
| 1761 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; |
| 1762 __base* __t = (__base*)&__tempbuf; |
| 1763 __f_->__clone(__t); |
| 1764 __f_->destroy(); |
| 1765 __f_ = 0; |
| 1766 __f.__f_->__clone((__base*)&__buf_); |
| 1767 __f.__f_->destroy(); |
| 1768 __f.__f_ = 0; |
| 1769 __f_ = (__base*)&__buf_; |
| 1770 __t->__clone((__base*)&__f.__buf_); |
| 1771 __t->destroy(); |
| 1772 __f.__f_ = (__base*)&__f.__buf_; |
| 1773 } |
| 1774 else if (__f_ == (__base*)&__buf_) |
| 1775 { |
| 1776 __f_->__clone((__base*)&__f.__buf_); |
| 1777 __f_->destroy(); |
| 1778 __f_ = __f.__f_; |
| 1779 __f.__f_ = (__base*)&__f.__buf_; |
| 1780 } |
| 1781 else if (__f.__f_ == (__base*)&__f.__buf_) |
| 1782 { |
| 1783 __f.__f_->__clone((__base*)&__buf_); |
| 1784 __f.__f_->destroy(); |
| 1785 __f.__f_ = __f_; |
| 1786 __f_ = (__base*)&__buf_; |
| 1787 } |
| 1788 else |
| 1789 _VSTD::swap(__f_, __f.__f_); |
| 1790 } |
| 1791 |
| 1792 template<class _Rp, class _A0, class _A1, class _A2> |
| 1793 _Rp |
| 1794 function<_Rp(_A0, _A1, _A2)>::operator()(_A0 __a0, _A1 __a1, _A2 __a2) const |
| 1795 { |
| 1796 #ifndef _LIBCPP_NO_EXCEPTIONS |
| 1797 if (__f_ == 0) |
| 1798 throw bad_function_call(); |
| 1799 #endif // _LIBCPP_NO_EXCEPTIONS |
| 1800 return (*__f_)(__a0, __a1, __a2); |
| 1801 } |
| 1802 |
| 1803 #ifndef _LIBCPP_NO_RTTI |
| 1804 |
| 1805 template<class _Rp, class _A0, class _A1, class _A2> |
| 1806 const std::type_info& |
| 1807 function<_Rp(_A0, _A1, _A2)>::target_type() const |
| 1808 { |
| 1809 if (__f_ == 0) |
| 1810 return typeid(void); |
| 1811 return __f_->target_type(); |
| 1812 } |
| 1813 |
| 1814 template<class _Rp, class _A0, class _A1, class _A2> |
| 1815 template <typename _Tp> |
| 1816 _Tp* |
| 1817 function<_Rp(_A0, _A1, _A2)>::target() |
| 1818 { |
| 1819 if (__f_ == 0) |
| 1820 return (_Tp*)0; |
| 1821 return (_Tp*)__f_->target(typeid(_Tp)); |
| 1822 } |
| 1823 |
| 1824 template<class _Rp, class _A0, class _A1, class _A2> |
| 1825 template <typename _Tp> |
| 1826 const _Tp* |
| 1827 function<_Rp(_A0, _A1, _A2)>::target() const |
| 1828 { |
| 1829 if (__f_ == 0) |
| 1830 return (const _Tp*)0; |
| 1831 return (const _Tp*)__f_->target(typeid(_Tp)); |
| 1832 } |
| 1833 |
| 1834 #endif // _LIBCPP_NO_RTTI |
| 1835 |
| 1836 template <class _Fp> |
| 1837 inline _LIBCPP_INLINE_VISIBILITY |
| 1838 bool |
| 1839 operator==(const function<_Fp>& __f, nullptr_t) {return !__f;} |
| 1840 |
| 1841 template <class _Fp> |
| 1842 inline _LIBCPP_INLINE_VISIBILITY |
| 1843 bool |
| 1844 operator==(nullptr_t, const function<_Fp>& __f) {return !__f;} |
| 1845 |
| 1846 template <class _Fp> |
| 1847 inline _LIBCPP_INLINE_VISIBILITY |
| 1848 bool |
| 1849 operator!=(const function<_Fp>& __f, nullptr_t) {return (bool)__f;} |
| 1850 |
| 1851 template <class _Fp> |
| 1852 inline _LIBCPP_INLINE_VISIBILITY |
| 1853 bool |
| 1854 operator!=(nullptr_t, const function<_Fp>& __f) {return (bool)__f;} |
| 1855 |
| 1856 template <class _Fp> |
| 1857 inline _LIBCPP_INLINE_VISIBILITY |
| 1858 void |
| 1859 swap(function<_Fp>& __x, function<_Fp>& __y) |
| 1860 {return __x.swap(__y);} |
| 1861 |
| 1862 template<class _Tp> struct __is_bind_expression : public false_type {}; |
| 1863 template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_bind_expression |
| 1864 : public __is_bind_expression<typename remove_cv<_Tp>::type> {}; |
| 1865 |
| 1866 template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {
}; |
| 1867 template<class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_placeholder |
| 1868 : public __is_placeholder<typename remove_cv<_Tp>::type> {}; |
| 1869 |
| 1870 namespace placeholders |
| 1871 { |
| 1872 |
| 1873 template <int _Np> struct __ph {}; |
| 1874 |
| 1875 extern __ph<1> _1; |
| 1876 extern __ph<2> _2; |
| 1877 extern __ph<3> _3; |
| 1878 extern __ph<4> _4; |
| 1879 extern __ph<5> _5; |
| 1880 extern __ph<6> _6; |
| 1881 extern __ph<7> _7; |
| 1882 extern __ph<8> _8; |
| 1883 extern __ph<9> _9; |
| 1884 extern __ph<10> _10; |
| 1885 |
| 1886 } // placeholders |
| 1887 |
| 1888 template<int _Np> |
| 1889 struct __is_placeholder<placeholders::__ph<_Np> > |
| 1890 : public integral_constant<int, _Np> {}; |
| 1891 |
| 1892 template <class _Tp, class _Uj> |
| 1893 inline _LIBCPP_INLINE_VISIBILITY |
| 1894 _Tp& |
| 1895 __mu(reference_wrapper<_Tp> __t, _Uj&) |
| 1896 { |
| 1897 return __t.get(); |
| 1898 } |
| 1899 /* |
| 1900 template <bool _IsBindExpr, class _Ti, class ..._Uj> |
| 1901 struct __mu_return1 {}; |
| 1902 |
| 1903 template <class _Ti, class ..._Uj> |
| 1904 struct __mu_return1<true, _Ti, _Uj...> |
| 1905 { |
| 1906 typedef typename result_of<_Ti(_Uj...)>::type type; |
| 1907 }; |
| 1908 |
| 1909 template <class _Ti, class ..._Uj, size_t ..._Indx> |
| 1910 inline _LIBCPP_INLINE_VISIBILITY |
| 1911 typename __mu_return1<true, _Ti, _Uj...>::type |
| 1912 __mu_expand(_Ti& __ti, tuple<_Uj...>&& __uj, __tuple_indices<_Indx...>) |
| 1913 { |
| 1914 __ti(_VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__u
j))...); |
| 1915 } |
| 1916 |
| 1917 template <class _Ti, class ..._Uj> |
| 1918 inline _LIBCPP_INLINE_VISIBILITY |
| 1919 typename enable_if |
| 1920 < |
| 1921 is_bind_expression<_Ti>::value, |
| 1922 typename __mu_return1<is_bind_expression<_Ti>::value, _Ti, _Uj...>::type |
| 1923 >::type |
| 1924 __mu(_Ti& __ti, tuple<_Uj...>& __uj) |
| 1925 { |
| 1926 typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices; |
| 1927 return __mu_expand(__ti, __uj, __indices()); |
| 1928 } |
| 1929 |
| 1930 template <bool IsPh, class _Ti, class _Uj> |
| 1931 struct __mu_return2 {}; |
| 1932 |
| 1933 template <class _Ti, class _Uj> |
| 1934 struct __mu_return2<true, _Ti, _Uj> |
| 1935 { |
| 1936 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type ty
pe; |
| 1937 }; |
| 1938 |
| 1939 template <class _Ti, class _Uj> |
| 1940 inline _LIBCPP_INLINE_VISIBILITY |
| 1941 typename enable_if |
| 1942 < |
| 1943 0 < is_placeholder<_Ti>::value, |
| 1944 typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type |
| 1945 >::type |
| 1946 __mu(_Ti&, _Uj& __uj) |
| 1947 { |
| 1948 const size_t _Indx = is_placeholder<_Ti>::value - 1; |
| 1949 // compiler bug workaround |
| 1950 typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj); |
| 1951 return __t; |
| 1952 // return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>
(__uj)); |
| 1953 } |
| 1954 |
| 1955 template <class _Ti, class _Uj> |
| 1956 inline _LIBCPP_INLINE_VISIBILITY |
| 1957 typename enable_if |
| 1958 < |
| 1959 !is_bind_expression<_Ti>::value && |
| 1960 is_placeholder<_Ti>::value == 0 && |
| 1961 !__is_reference_wrapper<_Ti>::value, |
| 1962 _Ti& |
| 1963 >::type |
| 1964 __mu(_Ti& __ti, _Uj& __uj) |
| 1965 { |
| 1966 return __ti; |
| 1967 } |
| 1968 |
| 1969 template <class _Ti, bool IsBindEx, bool IsPh, class _TupleUj> |
| 1970 struct ____mu_return; |
| 1971 |
| 1972 template <class _Ti, class ..._Uj> |
| 1973 struct ____mu_return<_Ti, true, false, tuple<_Uj...> > |
| 1974 { |
| 1975 typedef typename result_of<_Ti(_Uj...)>::type type; |
| 1976 }; |
| 1977 |
| 1978 template <class _Ti, class _TupleUj> |
| 1979 struct ____mu_return<_Ti, false, true, _TupleUj> |
| 1980 { |
| 1981 typedef typename tuple_element<is_placeholder<_Ti>::value - 1, |
| 1982 _TupleUj>::type&& type; |
| 1983 }; |
| 1984 |
| 1985 template <class _Ti, class _TupleUj> |
| 1986 struct ____mu_return<_Ti, false, false, _TupleUj> |
| 1987 { |
| 1988 typedef _Ti& type; |
| 1989 }; |
| 1990 |
| 1991 template <class _Ti, class _TupleUj> |
| 1992 struct __mu_return |
| 1993 : public ____mu_return<_Ti, |
| 1994 is_bind_expression<_Ti>::value, |
| 1995 0 < is_placeholder<_Ti>::value, |
| 1996 _TupleUj> |
| 1997 { |
| 1998 }; |
| 1999 |
| 2000 template <class _Ti, class _TupleUj> |
| 2001 struct __mu_return<reference_wrapper<_Ti>, _TupleUj> |
| 2002 { |
| 2003 typedef _Ti& type; |
| 2004 }; |
| 2005 |
| 2006 template <class _Fp, class _BoundArgs, class _TupleUj> |
| 2007 struct __bind_return; |
| 2008 |
| 2009 template <class _Fp, class ..._BoundArgs, class _TupleUj> |
| 2010 struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj> |
| 2011 { |
| 2012 typedef typename __ref_return |
| 2013 < |
| 2014 _Fp&, |
| 2015 typename __mu_return |
| 2016 < |
| 2017 _BoundArgs, |
| 2018 _TupleUj |
| 2019 >::type... |
| 2020 >::type type; |
| 2021 }; |
| 2022 |
| 2023 template <class _Fp, class ..._BoundArgs, class _TupleUj> |
| 2024 struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj> |
| 2025 { |
| 2026 typedef typename __ref_return |
| 2027 < |
| 2028 _Fp&, |
| 2029 typename __mu_return |
| 2030 < |
| 2031 const _BoundArgs, |
| 2032 _TupleUj |
| 2033 >::type... |
| 2034 >::type type; |
| 2035 }; |
| 2036 |
| 2037 template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args> |
| 2038 inline _LIBCPP_INLINE_VISIBILITY |
| 2039 typename __bind_return<_Fp, _BoundArgs, _Args>::type |
| 2040 __apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, |
| 2041 _Args&& __args) |
| 2042 { |
| 2043 return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...); |
| 2044 } |
| 2045 |
| 2046 template<class _Fp, class ..._BoundArgs> |
| 2047 class __bind |
| 2048 { |
| 2049 _Fp __f_; |
| 2050 tuple<_BoundArgs...> __bound_args_; |
| 2051 |
| 2052 typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices
; |
| 2053 public: |
| 2054 template <class _Gp, class ..._BA> |
| 2055 explicit __bind(_Gp&& __f, _BA&& ...__bound_args) |
| 2056 : __f_(_VSTD::forward<_Gp>(__f)), |
| 2057 __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {} |
| 2058 |
| 2059 template <class ..._Args> |
| 2060 typename __bind_return<_Fp, tuple<_BoundArgs...>, tuple<_Args&&...> >::t
ype |
| 2061 operator()(_Args&& ...__args) |
| 2062 { |
| 2063 // compiler bug workaround |
| 2064 return __apply_functor(__f_, __bound_args_, __indices(), |
| 2065 tuple<_Args&&...>(__args...)); |
| 2066 } |
| 2067 |
| 2068 template <class ..._Args> |
| 2069 typename __bind_return<_Fp, tuple<_BoundArgs...>, tuple<_Args&&...> >::t
ype |
| 2070 operator()(_Args&& ...__args) const |
| 2071 { |
| 2072 return __apply_functor(__f_, __bound_args_, __indices(), |
| 2073 tuple<_Args&&...>(__args...)); |
| 2074 } |
| 2075 }; |
| 2076 |
| 2077 template<class _Fp, class ..._BoundArgs> |
| 2078 struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {}; |
| 2079 |
| 2080 template<class _Rp, class _Fp, class ..._BoundArgs> |
| 2081 class __bind_r |
| 2082 : public __bind<_Fp, _BoundArgs...> |
| 2083 { |
| 2084 typedef __bind<_Fp, _BoundArgs...> base; |
| 2085 public: |
| 2086 typedef _Rp result_type; |
| 2087 |
| 2088 template <class _Gp, class ..._BA> |
| 2089 explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args) |
| 2090 : base(_VSTD::forward<_Gp>(__f), |
| 2091 _VSTD::forward<_BA>(__bound_args)...) {} |
| 2092 |
| 2093 template <class ..._Args> |
| 2094 result_type |
| 2095 operator()(_Args&& ...__args) |
| 2096 { |
| 2097 return base::operator()(_VSTD::forward<_Args>(__args)...); |
| 2098 } |
| 2099 |
| 2100 template <class ..._Args> |
| 2101 result_type |
| 2102 operator()(_Args&& ...__args) const |
| 2103 { |
| 2104 return base::operator()(_VSTD::forward<_Args>(__args)...); |
| 2105 } |
| 2106 }; |
| 2107 |
| 2108 template<class _Rp, class _Fp, class ..._BoundArgs> |
| 2109 struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_ty
pe {}; |
| 2110 |
| 2111 template<class _Fp, class ..._BoundArgs> |
| 2112 inline _LIBCPP_INLINE_VISIBILITY |
| 2113 __bind<typename decay<_Fp>::type, typename decay<_BoundArgs>::type...> |
| 2114 bind(_Fp&& __f, _BoundArgs&&... __bound_args) |
| 2115 { |
| 2116 typedef __bind<typename decay<_Fp>::type, typename decay<_BoundArgs>::type..
.> type; |
| 2117 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_arg
s)...); |
| 2118 } |
| 2119 |
| 2120 template<class _Rp, class _Fp, class ..._BoundArgs> |
| 2121 inline _LIBCPP_INLINE_VISIBILITY |
| 2122 __bind_r<_Rp, typename decay<_Fp>::type, typename decay<_BoundArgs>::type...> |
| 2123 bind(_Fp&& __f, _BoundArgs&&... __bound_args) |
| 2124 { |
| 2125 typedef __bind_r<_Rp, typename decay<_Fp>::type, typename decay<_BoundArgs>:
:type...> type; |
| 2126 return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_arg
s)...); |
| 2127 } |
| 2128 */ |
| 2129 |
| 2130 #endif // _LIBCPP_FUNCTIONAL_03 |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 75213003:
Add libc++ and libc++abi to third-party. (Closed)
Base URL: https://src.chromium.org/chrome/trunk/src/