1 // -*- C++ -*- 2 //===----------------------------------------------------------------------===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef _LIBCPP___FUNCTIONAL_OPERATIONS_H 11 #define _LIBCPP___FUNCTIONAL_OPERATIONS_H 12 13 #include <__config> 14 #include <__functional/binary_function.h> 15 #include <__functional/unary_function.h> 16 #include <__utility/forward.h> 17 18 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 19 # pragma GCC system_header 20 #endif 21 22 _LIBCPP_BEGIN_NAMESPACE_STD 23 24 // Arithmetic operations 25 26 #if _LIBCPP_STD_VER > 11 27 template <class _Tp = void> 28 #else 29 template <class _Tp> 30 #endif 31 struct _LIBCPP_TEMPLATE_VIS plus 32 : __binary_function<_Tp, _Tp, _Tp> 33 { 34 typedef _Tp __result_type; // used by valarray 35 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 36 _Tp operator()(const _Tp& __x, const _Tp& __y) const 37 {return __x + __y;} 38 }; 39 40 #if _LIBCPP_STD_VER > 11 41 template <> 42 struct _LIBCPP_TEMPLATE_VIS plus<void> 43 { 44 template <class _T1, class _T2> 45 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 46 auto operator()(_T1&& __t, _T2&& __u) const 47 noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) 48 -> decltype( _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) 49 { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } 50 typedef void is_transparent; 51 }; 52 #endif 53 54 #if _LIBCPP_STD_VER > 11 55 template <class _Tp = void> 56 #else 57 template <class _Tp> 58 #endif 59 struct _LIBCPP_TEMPLATE_VIS minus 60 : __binary_function<_Tp, _Tp, _Tp> 61 { 62 typedef _Tp __result_type; // used by valarray 63 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 64 _Tp operator()(const _Tp& __x, const _Tp& __y) const 65 {return __x - __y;} 66 }; 67 68 #if _LIBCPP_STD_VER > 11 69 template <> 70 struct _LIBCPP_TEMPLATE_VIS minus<void> 71 { 72 template <class _T1, class _T2> 73 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 74 auto operator()(_T1&& __t, _T2&& __u) const 75 noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) 76 -> decltype( _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) 77 { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } 78 typedef void is_transparent; 79 }; 80 #endif 81 82 #if _LIBCPP_STD_VER > 11 83 template <class _Tp = void> 84 #else 85 template <class _Tp> 86 #endif 87 struct _LIBCPP_TEMPLATE_VIS multiplies 88 : __binary_function<_Tp, _Tp, _Tp> 89 { 90 typedef _Tp __result_type; // used by valarray 91 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 92 _Tp operator()(const _Tp& __x, const _Tp& __y) const 93 {return __x * __y;} 94 }; 95 96 #if _LIBCPP_STD_VER > 11 97 template <> 98 struct _LIBCPP_TEMPLATE_VIS multiplies<void> 99 { 100 template <class _T1, class _T2> 101 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 102 auto operator()(_T1&& __t, _T2&& __u) const 103 noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) 104 -> decltype( _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) 105 { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } 106 typedef void is_transparent; 107 }; 108 #endif 109 110 #if _LIBCPP_STD_VER > 11 111 template <class _Tp = void> 112 #else 113 template <class _Tp> 114 #endif 115 struct _LIBCPP_TEMPLATE_VIS divides 116 : __binary_function<_Tp, _Tp, _Tp> 117 { 118 typedef _Tp __result_type; // used by valarray 119 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 120 _Tp operator()(const _Tp& __x, const _Tp& __y) const 121 {return __x / __y;} 122 }; 123 124 #if _LIBCPP_STD_VER > 11 125 template <> 126 struct _LIBCPP_TEMPLATE_VIS divides<void> 127 { 128 template <class _T1, class _T2> 129 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 130 auto operator()(_T1&& __t, _T2&& __u) const 131 noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) 132 -> decltype( _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) 133 { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } 134 typedef void is_transparent; 135 }; 136 #endif 137 138 #if _LIBCPP_STD_VER > 11 139 template <class _Tp = void> 140 #else 141 template <class _Tp> 142 #endif 143 struct _LIBCPP_TEMPLATE_VIS modulus 144 : __binary_function<_Tp, _Tp, _Tp> 145 { 146 typedef _Tp __result_type; // used by valarray 147 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 148 _Tp operator()(const _Tp& __x, const _Tp& __y) const 149 {return __x % __y;} 150 }; 151 152 #if _LIBCPP_STD_VER > 11 153 template <> 154 struct _LIBCPP_TEMPLATE_VIS modulus<void> 155 { 156 template <class _T1, class _T2> 157 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 158 auto operator()(_T1&& __t, _T2&& __u) const 159 noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) 160 -> decltype( _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) 161 { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } 162 typedef void is_transparent; 163 }; 164 #endif 165 166 #if _LIBCPP_STD_VER > 11 167 template <class _Tp = void> 168 #else 169 template <class _Tp> 170 #endif 171 struct _LIBCPP_TEMPLATE_VIS negate 172 : __unary_function<_Tp, _Tp> 173 { 174 typedef _Tp __result_type; // used by valarray 175 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 176 _Tp operator()(const _Tp& __x) const 177 {return -__x;} 178 }; 179 180 #if _LIBCPP_STD_VER > 11 181 template <> 182 struct _LIBCPP_TEMPLATE_VIS negate<void> 183 { 184 template <class _Tp> 185 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 186 auto operator()(_Tp&& __x) const 187 noexcept(noexcept(- _VSTD::forward<_Tp>(__x))) 188 -> decltype( - _VSTD::forward<_Tp>(__x)) 189 { return - _VSTD::forward<_Tp>(__x); } 190 typedef void is_transparent; 191 }; 192 #endif 193 194 // Bitwise operations 195 196 #if _LIBCPP_STD_VER > 11 197 template <class _Tp = void> 198 #else 199 template <class _Tp> 200 #endif 201 struct _LIBCPP_TEMPLATE_VIS bit_and 202 : __binary_function<_Tp, _Tp, _Tp> 203 { 204 typedef _Tp __result_type; // used by valarray 205 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 206 _Tp operator()(const _Tp& __x, const _Tp& __y) const 207 {return __x & __y;} 208 }; 209 210 #if _LIBCPP_STD_VER > 11 211 template <> 212 struct _LIBCPP_TEMPLATE_VIS bit_and<void> 213 { 214 template <class _T1, class _T2> 215 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 216 auto operator()(_T1&& __t, _T2&& __u) const 217 noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) 218 -> decltype( _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) 219 { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } 220 typedef void is_transparent; 221 }; 222 #endif 223 224 #if _LIBCPP_STD_VER > 11 225 template <class _Tp = void> 226 struct _LIBCPP_TEMPLATE_VIS bit_not 227 : __unary_function<_Tp, _Tp> 228 { 229 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 230 _Tp operator()(const _Tp& __x) const 231 {return ~__x;} 232 }; 233 234 template <> 235 struct _LIBCPP_TEMPLATE_VIS bit_not<void> 236 { 237 template <class _Tp> 238 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 239 auto operator()(_Tp&& __x) const 240 noexcept(noexcept(~_VSTD::forward<_Tp>(__x))) 241 -> decltype( ~_VSTD::forward<_Tp>(__x)) 242 { return ~_VSTD::forward<_Tp>(__x); } 243 typedef void is_transparent; 244 }; 245 #endif 246 247 #if _LIBCPP_STD_VER > 11 248 template <class _Tp = void> 249 #else 250 template <class _Tp> 251 #endif 252 struct _LIBCPP_TEMPLATE_VIS bit_or 253 : __binary_function<_Tp, _Tp, _Tp> 254 { 255 typedef _Tp __result_type; // used by valarray 256 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 257 _Tp operator()(const _Tp& __x, const _Tp& __y) const 258 {return __x | __y;} 259 }; 260 261 #if _LIBCPP_STD_VER > 11 262 template <> 263 struct _LIBCPP_TEMPLATE_VIS bit_or<void> 264 { 265 template <class _T1, class _T2> 266 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 267 auto operator()(_T1&& __t, _T2&& __u) const 268 noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) 269 -> decltype( _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) 270 { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } 271 typedef void is_transparent; 272 }; 273 #endif 274 275 #if _LIBCPP_STD_VER > 11 276 template <class _Tp = void> 277 #else 278 template <class _Tp> 279 #endif 280 struct _LIBCPP_TEMPLATE_VIS bit_xor 281 : __binary_function<_Tp, _Tp, _Tp> 282 { 283 typedef _Tp __result_type; // used by valarray 284 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 285 _Tp operator()(const _Tp& __x, const _Tp& __y) const 286 {return __x ^ __y;} 287 }; 288 289 #if _LIBCPP_STD_VER > 11 290 template <> 291 struct _LIBCPP_TEMPLATE_VIS bit_xor<void> 292 { 293 template <class _T1, class _T2> 294 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 295 auto operator()(_T1&& __t, _T2&& __u) const 296 noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) 297 -> decltype( _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) 298 { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } 299 typedef void is_transparent; 300 }; 301 #endif 302 303 // Comparison operations 304 305 #if _LIBCPP_STD_VER > 11 306 template <class _Tp = void> 307 #else 308 template <class _Tp> 309 #endif 310 struct _LIBCPP_TEMPLATE_VIS equal_to 311 : __binary_function<_Tp, _Tp, bool> 312 { 313 typedef bool __result_type; // used by valarray 314 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 315 bool operator()(const _Tp& __x, const _Tp& __y) const 316 {return __x == __y;} 317 }; 318 319 #if _LIBCPP_STD_VER > 11 320 template <> 321 struct _LIBCPP_TEMPLATE_VIS equal_to<void> 322 { 323 template <class _T1, class _T2> 324 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 325 auto operator()(_T1&& __t, _T2&& __u) const 326 noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) 327 -> decltype( _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) 328 { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } 329 typedef void is_transparent; 330 }; 331 #endif 332 333 #if _LIBCPP_STD_VER > 11 334 template <class _Tp = void> 335 #else 336 template <class _Tp> 337 #endif 338 struct _LIBCPP_TEMPLATE_VIS not_equal_to 339 : __binary_function<_Tp, _Tp, bool> 340 { 341 typedef bool __result_type; // used by valarray 342 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 343 bool operator()(const _Tp& __x, const _Tp& __y) const 344 {return __x != __y;} 345 }; 346 347 #if _LIBCPP_STD_VER > 11 348 template <> 349 struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> 350 { 351 template <class _T1, class _T2> 352 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 353 auto operator()(_T1&& __t, _T2&& __u) const 354 noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) 355 -> decltype( _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) 356 { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } 357 typedef void is_transparent; 358 }; 359 #endif 360 361 #if _LIBCPP_STD_VER > 11 362 template <class _Tp = void> 363 #else 364 template <class _Tp> 365 #endif 366 struct _LIBCPP_TEMPLATE_VIS less 367 : __binary_function<_Tp, _Tp, bool> 368 { 369 typedef bool __result_type; // used by valarray 370 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 371 bool operator()(const _Tp& __x, const _Tp& __y) const 372 {return __x < __y;} 373 }; 374 375 #if _LIBCPP_STD_VER > 11 376 template <> 377 struct _LIBCPP_TEMPLATE_VIS less<void> 378 { 379 template <class _T1, class _T2> 380 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 381 auto operator()(_T1&& __t, _T2&& __u) const 382 noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))) 383 -> decltype( _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) 384 { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } 385 typedef void is_transparent; 386 }; 387 #endif 388 389 #if _LIBCPP_STD_VER > 11 390 template <class _Tp = void> 391 #else 392 template <class _Tp> 393 #endif 394 struct _LIBCPP_TEMPLATE_VIS less_equal 395 : __binary_function<_Tp, _Tp, bool> 396 { 397 typedef bool __result_type; // used by valarray 398 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 399 bool operator()(const _Tp& __x, const _Tp& __y) const 400 {return __x <= __y;} 401 }; 402 403 #if _LIBCPP_STD_VER > 11 404 template <> 405 struct _LIBCPP_TEMPLATE_VIS less_equal<void> 406 { 407 template <class _T1, class _T2> 408 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 409 auto operator()(_T1&& __t, _T2&& __u) const 410 noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) 411 -> decltype( _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) 412 { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } 413 typedef void is_transparent; 414 }; 415 #endif 416 417 #if _LIBCPP_STD_VER > 11 418 template <class _Tp = void> 419 #else 420 template <class _Tp> 421 #endif 422 struct _LIBCPP_TEMPLATE_VIS greater_equal 423 : __binary_function<_Tp, _Tp, bool> 424 { 425 typedef bool __result_type; // used by valarray 426 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 427 bool operator()(const _Tp& __x, const _Tp& __y) const 428 {return __x >= __y;} 429 }; 430 431 #if _LIBCPP_STD_VER > 11 432 template <> 433 struct _LIBCPP_TEMPLATE_VIS greater_equal<void> 434 { 435 template <class _T1, class _T2> 436 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 437 auto operator()(_T1&& __t, _T2&& __u) const 438 noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) 439 -> decltype( _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) 440 { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } 441 typedef void is_transparent; 442 }; 443 #endif 444 445 #if _LIBCPP_STD_VER > 11 446 template <class _Tp = void> 447 #else 448 template <class _Tp> 449 #endif 450 struct _LIBCPP_TEMPLATE_VIS greater 451 : __binary_function<_Tp, _Tp, bool> 452 { 453 typedef bool __result_type; // used by valarray 454 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 455 bool operator()(const _Tp& __x, const _Tp& __y) const 456 {return __x > __y;} 457 }; 458 459 #if _LIBCPP_STD_VER > 11 460 template <> 461 struct _LIBCPP_TEMPLATE_VIS greater<void> 462 { 463 template <class _T1, class _T2> 464 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 465 auto operator()(_T1&& __t, _T2&& __u) const 466 noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) 467 -> decltype( _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) 468 { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } 469 typedef void is_transparent; 470 }; 471 #endif 472 473 // Logical operations 474 475 #if _LIBCPP_STD_VER > 11 476 template <class _Tp = void> 477 #else 478 template <class _Tp> 479 #endif 480 struct _LIBCPP_TEMPLATE_VIS logical_and 481 : __binary_function<_Tp, _Tp, bool> 482 { 483 typedef bool __result_type; // used by valarray 484 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 485 bool operator()(const _Tp& __x, const _Tp& __y) const 486 {return __x && __y;} 487 }; 488 489 #if _LIBCPP_STD_VER > 11 490 template <> 491 struct _LIBCPP_TEMPLATE_VIS logical_and<void> 492 { 493 template <class _T1, class _T2> 494 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 495 auto operator()(_T1&& __t, _T2&& __u) const 496 noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) 497 -> decltype( _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) 498 { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } 499 typedef void is_transparent; 500 }; 501 #endif 502 503 #if _LIBCPP_STD_VER > 11 504 template <class _Tp = void> 505 #else 506 template <class _Tp> 507 #endif 508 struct _LIBCPP_TEMPLATE_VIS logical_not 509 : __unary_function<_Tp, bool> 510 { 511 typedef bool __result_type; // used by valarray 512 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 513 bool operator()(const _Tp& __x) const 514 {return !__x;} 515 }; 516 517 #if _LIBCPP_STD_VER > 11 518 template <> 519 struct _LIBCPP_TEMPLATE_VIS logical_not<void> 520 { 521 template <class _Tp> 522 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 523 auto operator()(_Tp&& __x) const 524 noexcept(noexcept(!_VSTD::forward<_Tp>(__x))) 525 -> decltype( !_VSTD::forward<_Tp>(__x)) 526 { return !_VSTD::forward<_Tp>(__x); } 527 typedef void is_transparent; 528 }; 529 #endif 530 531 #if _LIBCPP_STD_VER > 11 532 template <class _Tp = void> 533 #else 534 template <class _Tp> 535 #endif 536 struct _LIBCPP_TEMPLATE_VIS logical_or 537 : __binary_function<_Tp, _Tp, bool> 538 { 539 typedef bool __result_type; // used by valarray 540 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 541 bool operator()(const _Tp& __x, const _Tp& __y) const 542 {return __x || __y;} 543 }; 544 545 #if _LIBCPP_STD_VER > 11 546 template <> 547 struct _LIBCPP_TEMPLATE_VIS logical_or<void> 548 { 549 template <class _T1, class _T2> 550 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 551 auto operator()(_T1&& __t, _T2&& __u) const 552 noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) 553 -> decltype( _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) 554 { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } 555 typedef void is_transparent; 556 }; 557 #endif 558 559 _LIBCPP_END_NAMESPACE_STD 560 561 #endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H 562