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 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 27 #if _LIBCPP_STD_VER > 11 28 template <class _Tp = void> 29 #else 30 template <class _Tp> 31 #endif 32 struct _LIBCPP_TEMPLATE_VIS plus 33 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 34 : binary_function<_Tp, _Tp, _Tp> 35 #endif 36 { 37 _LIBCPP_SUPPRESS_DEPRECATED_POP 38 typedef _Tp __result_type; // used by valarray 39 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 40 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 41 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 42 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 43 #endif 44 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 45 _Tp operator()(const _Tp& __x, const _Tp& __y) const 46 {return __x + __y;} 47 }; 48 49 #if _LIBCPP_STD_VER > 11 50 template <> 51 struct _LIBCPP_TEMPLATE_VIS plus<void> 52 { 53 template <class _T1, class _T2> 54 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 55 auto operator()(_T1&& __t, _T2&& __u) const 56 noexcept(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))) 57 -> decltype( _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)) 58 { return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); } 59 typedef void is_transparent; 60 }; 61 #endif 62 63 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 64 #if _LIBCPP_STD_VER > 11 65 template <class _Tp = void> 66 #else 67 template <class _Tp> 68 #endif 69 struct _LIBCPP_TEMPLATE_VIS minus 70 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 71 : binary_function<_Tp, _Tp, _Tp> 72 #endif 73 { 74 _LIBCPP_SUPPRESS_DEPRECATED_POP 75 typedef _Tp __result_type; // used by valarray 76 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 77 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 78 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 79 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 80 #endif 81 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 82 _Tp operator()(const _Tp& __x, const _Tp& __y) const 83 {return __x - __y;} 84 }; 85 86 #if _LIBCPP_STD_VER > 11 87 template <> 88 struct _LIBCPP_TEMPLATE_VIS minus<void> 89 { 90 template <class _T1, class _T2> 91 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 92 auto operator()(_T1&& __t, _T2&& __u) const 93 noexcept(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))) 94 -> decltype( _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)) 95 { return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); } 96 typedef void is_transparent; 97 }; 98 #endif 99 100 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 101 #if _LIBCPP_STD_VER > 11 102 template <class _Tp = void> 103 #else 104 template <class _Tp> 105 #endif 106 struct _LIBCPP_TEMPLATE_VIS multiplies 107 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 108 : binary_function<_Tp, _Tp, _Tp> 109 #endif 110 { 111 _LIBCPP_SUPPRESS_DEPRECATED_POP 112 typedef _Tp __result_type; // used by valarray 113 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 114 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 115 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 116 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 117 #endif 118 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 119 _Tp operator()(const _Tp& __x, const _Tp& __y) const 120 {return __x * __y;} 121 }; 122 123 #if _LIBCPP_STD_VER > 11 124 template <> 125 struct _LIBCPP_TEMPLATE_VIS multiplies<void> 126 { 127 template <class _T1, class _T2> 128 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 129 auto operator()(_T1&& __t, _T2&& __u) const 130 noexcept(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))) 131 -> decltype( _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)) 132 { return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); } 133 typedef void is_transparent; 134 }; 135 #endif 136 137 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 138 #if _LIBCPP_STD_VER > 11 139 template <class _Tp = void> 140 #else 141 template <class _Tp> 142 #endif 143 struct _LIBCPP_TEMPLATE_VIS divides 144 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 145 : binary_function<_Tp, _Tp, _Tp> 146 #endif 147 { 148 _LIBCPP_SUPPRESS_DEPRECATED_POP 149 typedef _Tp __result_type; // used by valarray 150 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 151 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 152 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 153 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 154 #endif 155 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 156 _Tp operator()(const _Tp& __x, const _Tp& __y) const 157 {return __x / __y;} 158 }; 159 160 #if _LIBCPP_STD_VER > 11 161 template <> 162 struct _LIBCPP_TEMPLATE_VIS divides<void> 163 { 164 template <class _T1, class _T2> 165 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 166 auto operator()(_T1&& __t, _T2&& __u) const 167 noexcept(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))) 168 -> decltype( _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)) 169 { return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); } 170 typedef void is_transparent; 171 }; 172 #endif 173 174 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 175 #if _LIBCPP_STD_VER > 11 176 template <class _Tp = void> 177 #else 178 template <class _Tp> 179 #endif 180 struct _LIBCPP_TEMPLATE_VIS modulus 181 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 182 : binary_function<_Tp, _Tp, _Tp> 183 #endif 184 { 185 _LIBCPP_SUPPRESS_DEPRECATED_POP 186 typedef _Tp __result_type; // used by valarray 187 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 188 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 189 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 190 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 191 #endif 192 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 193 _Tp operator()(const _Tp& __x, const _Tp& __y) const 194 {return __x % __y;} 195 }; 196 197 #if _LIBCPP_STD_VER > 11 198 template <> 199 struct _LIBCPP_TEMPLATE_VIS modulus<void> 200 { 201 template <class _T1, class _T2> 202 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 203 auto operator()(_T1&& __t, _T2&& __u) const 204 noexcept(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))) 205 -> decltype( _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)) 206 { return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); } 207 typedef void is_transparent; 208 }; 209 #endif 210 211 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 212 #if _LIBCPP_STD_VER > 11 213 template <class _Tp = void> 214 #else 215 template <class _Tp> 216 #endif 217 struct _LIBCPP_TEMPLATE_VIS negate 218 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 219 : unary_function<_Tp, _Tp> 220 #endif 221 { 222 _LIBCPP_SUPPRESS_DEPRECATED_POP 223 typedef _Tp __result_type; // used by valarray 224 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 225 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 226 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp argument_type; 227 #endif 228 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 229 _Tp operator()(const _Tp& __x) const 230 {return -__x;} 231 }; 232 233 #if _LIBCPP_STD_VER > 11 234 template <> 235 struct _LIBCPP_TEMPLATE_VIS negate<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 // Bitwise operations 248 249 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 250 #if _LIBCPP_STD_VER > 11 251 template <class _Tp = void> 252 #else 253 template <class _Tp> 254 #endif 255 struct _LIBCPP_TEMPLATE_VIS bit_and 256 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 257 : binary_function<_Tp, _Tp, _Tp> 258 #endif 259 { 260 _LIBCPP_SUPPRESS_DEPRECATED_POP 261 typedef _Tp __result_type; // used by valarray 262 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 263 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 264 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 265 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 266 #endif 267 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 268 _Tp operator()(const _Tp& __x, const _Tp& __y) const 269 {return __x & __y;} 270 }; 271 272 #if _LIBCPP_STD_VER > 11 273 template <> 274 struct _LIBCPP_TEMPLATE_VIS bit_and<void> 275 { 276 template <class _T1, class _T2> 277 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 278 auto operator()(_T1&& __t, _T2&& __u) const 279 noexcept(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))) 280 -> decltype( _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)) 281 { return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); } 282 typedef void is_transparent; 283 }; 284 #endif 285 286 #if _LIBCPP_STD_VER > 11 287 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 288 template <class _Tp = void> 289 struct _LIBCPP_TEMPLATE_VIS bit_not 290 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 291 : unary_function<_Tp, _Tp> 292 #endif 293 { 294 _LIBCPP_SUPPRESS_DEPRECATED_POP 295 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 296 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 297 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp argument_type; 298 #endif 299 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 300 _Tp operator()(const _Tp& __x) const 301 {return ~__x;} 302 }; 303 304 template <> 305 struct _LIBCPP_TEMPLATE_VIS bit_not<void> 306 { 307 template <class _Tp> 308 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 309 auto operator()(_Tp&& __x) const 310 noexcept(noexcept(~_VSTD::forward<_Tp>(__x))) 311 -> decltype( ~_VSTD::forward<_Tp>(__x)) 312 { return ~_VSTD::forward<_Tp>(__x); } 313 typedef void is_transparent; 314 }; 315 #endif 316 317 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 318 #if _LIBCPP_STD_VER > 11 319 template <class _Tp = void> 320 #else 321 template <class _Tp> 322 #endif 323 struct _LIBCPP_TEMPLATE_VIS bit_or 324 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 325 : binary_function<_Tp, _Tp, _Tp> 326 #endif 327 { 328 _LIBCPP_SUPPRESS_DEPRECATED_POP 329 typedef _Tp __result_type; // used by valarray 330 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 331 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 332 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 333 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 334 #endif 335 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 336 _Tp operator()(const _Tp& __x, const _Tp& __y) const 337 {return __x | __y;} 338 }; 339 340 #if _LIBCPP_STD_VER > 11 341 template <> 342 struct _LIBCPP_TEMPLATE_VIS bit_or<void> 343 { 344 template <class _T1, class _T2> 345 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 346 auto operator()(_T1&& __t, _T2&& __u) const 347 noexcept(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))) 348 -> decltype( _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)) 349 { return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); } 350 typedef void is_transparent; 351 }; 352 #endif 353 354 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 355 #if _LIBCPP_STD_VER > 11 356 template <class _Tp = void> 357 #else 358 template <class _Tp> 359 #endif 360 struct _LIBCPP_TEMPLATE_VIS bit_xor 361 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 362 : binary_function<_Tp, _Tp, _Tp> 363 #endif 364 { 365 _LIBCPP_SUPPRESS_DEPRECATED_POP 366 typedef _Tp __result_type; // used by valarray 367 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 368 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp result_type; 369 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 370 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 371 #endif 372 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 373 _Tp operator()(const _Tp& __x, const _Tp& __y) const 374 {return __x ^ __y;} 375 }; 376 377 #if _LIBCPP_STD_VER > 11 378 template <> 379 struct _LIBCPP_TEMPLATE_VIS bit_xor<void> 380 { 381 template <class _T1, class _T2> 382 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 383 auto operator()(_T1&& __t, _T2&& __u) const 384 noexcept(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))) 385 -> decltype( _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)) 386 { return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); } 387 typedef void is_transparent; 388 }; 389 #endif 390 391 // Comparison operations 392 393 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 394 #if _LIBCPP_STD_VER > 11 395 template <class _Tp = void> 396 #else 397 template <class _Tp> 398 #endif 399 struct _LIBCPP_TEMPLATE_VIS equal_to 400 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 401 : binary_function<_Tp, _Tp, bool> 402 #endif 403 { 404 _LIBCPP_SUPPRESS_DEPRECATED_POP 405 typedef bool __result_type; // used by valarray 406 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 407 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 408 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 409 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 410 #endif 411 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 412 bool operator()(const _Tp& __x, const _Tp& __y) const 413 {return __x == __y;} 414 }; 415 416 #if _LIBCPP_STD_VER > 11 417 template <> 418 struct _LIBCPP_TEMPLATE_VIS equal_to<void> 419 { 420 template <class _T1, class _T2> 421 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 422 auto operator()(_T1&& __t, _T2&& __u) const 423 noexcept(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))) 424 -> decltype( _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)) 425 { return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); } 426 typedef void is_transparent; 427 }; 428 #endif 429 430 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 431 #if _LIBCPP_STD_VER > 11 432 template <class _Tp = void> 433 #else 434 template <class _Tp> 435 #endif 436 struct _LIBCPP_TEMPLATE_VIS not_equal_to 437 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 438 : binary_function<_Tp, _Tp, bool> 439 #endif 440 { 441 _LIBCPP_SUPPRESS_DEPRECATED_POP 442 typedef bool __result_type; // used by valarray 443 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 444 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 445 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 446 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 447 #endif 448 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 449 bool operator()(const _Tp& __x, const _Tp& __y) const 450 {return __x != __y;} 451 }; 452 453 #if _LIBCPP_STD_VER > 11 454 template <> 455 struct _LIBCPP_TEMPLATE_VIS not_equal_to<void> 456 { 457 template <class _T1, class _T2> 458 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 459 auto operator()(_T1&& __t, _T2&& __u) const 460 noexcept(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))) 461 -> decltype( _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)) 462 { return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); } 463 typedef void is_transparent; 464 }; 465 #endif 466 467 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 468 #if _LIBCPP_STD_VER > 11 469 template <class _Tp = void> 470 #else 471 template <class _Tp> 472 #endif 473 struct _LIBCPP_TEMPLATE_VIS less 474 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 475 : binary_function<_Tp, _Tp, bool> 476 #endif 477 { 478 _LIBCPP_SUPPRESS_DEPRECATED_POP 479 typedef bool __result_type; // used by valarray 480 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 481 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 482 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 483 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 484 #endif 485 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 486 bool operator()(const _Tp& __x, const _Tp& __y) const 487 {return __x < __y;} 488 }; 489 490 #if _LIBCPP_STD_VER > 11 491 template <> 492 struct _LIBCPP_TEMPLATE_VIS less<void> 493 { 494 template <class _T1, class _T2> 495 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 496 auto operator()(_T1&& __t, _T2&& __u) const 497 noexcept(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))) 498 -> decltype( _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)) 499 { return _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); } 500 typedef void is_transparent; 501 }; 502 #endif 503 504 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 505 #if _LIBCPP_STD_VER > 11 506 template <class _Tp = void> 507 #else 508 template <class _Tp> 509 #endif 510 struct _LIBCPP_TEMPLATE_VIS less_equal 511 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 512 : binary_function<_Tp, _Tp, bool> 513 #endif 514 { 515 _LIBCPP_SUPPRESS_DEPRECATED_POP 516 typedef bool __result_type; // used by valarray 517 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 518 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 519 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 520 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 521 #endif 522 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 523 bool operator()(const _Tp& __x, const _Tp& __y) const 524 {return __x <= __y;} 525 }; 526 527 #if _LIBCPP_STD_VER > 11 528 template <> 529 struct _LIBCPP_TEMPLATE_VIS less_equal<void> 530 { 531 template <class _T1, class _T2> 532 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 533 auto operator()(_T1&& __t, _T2&& __u) const 534 noexcept(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))) 535 -> decltype( _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)) 536 { return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); } 537 typedef void is_transparent; 538 }; 539 #endif 540 541 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 542 #if _LIBCPP_STD_VER > 11 543 template <class _Tp = void> 544 #else 545 template <class _Tp> 546 #endif 547 struct _LIBCPP_TEMPLATE_VIS greater_equal 548 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 549 : binary_function<_Tp, _Tp, bool> 550 #endif 551 { 552 _LIBCPP_SUPPRESS_DEPRECATED_POP 553 typedef bool __result_type; // used by valarray 554 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 555 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 556 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 557 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 558 #endif 559 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 560 bool operator()(const _Tp& __x, const _Tp& __y) const 561 {return __x >= __y;} 562 }; 563 564 #if _LIBCPP_STD_VER > 11 565 template <> 566 struct _LIBCPP_TEMPLATE_VIS greater_equal<void> 567 { 568 template <class _T1, class _T2> 569 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 570 auto operator()(_T1&& __t, _T2&& __u) const 571 noexcept(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))) 572 -> decltype( _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)) 573 { return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); } 574 typedef void is_transparent; 575 }; 576 #endif 577 578 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 579 #if _LIBCPP_STD_VER > 11 580 template <class _Tp = void> 581 #else 582 template <class _Tp> 583 #endif 584 struct _LIBCPP_TEMPLATE_VIS greater 585 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 586 : binary_function<_Tp, _Tp, bool> 587 #endif 588 { 589 _LIBCPP_SUPPRESS_DEPRECATED_POP 590 typedef bool __result_type; // used by valarray 591 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 592 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 593 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 594 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 595 #endif 596 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 597 bool operator()(const _Tp& __x, const _Tp& __y) const 598 {return __x > __y;} 599 }; 600 601 #if _LIBCPP_STD_VER > 11 602 template <> 603 struct _LIBCPP_TEMPLATE_VIS greater<void> 604 { 605 template <class _T1, class _T2> 606 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 607 auto operator()(_T1&& __t, _T2&& __u) const 608 noexcept(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))) 609 -> decltype( _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)) 610 { return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); } 611 typedef void is_transparent; 612 }; 613 #endif 614 615 // Logical operations 616 617 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 618 #if _LIBCPP_STD_VER > 11 619 template <class _Tp = void> 620 #else 621 template <class _Tp> 622 #endif 623 struct _LIBCPP_TEMPLATE_VIS logical_and 624 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 625 : binary_function<_Tp, _Tp, bool> 626 #endif 627 { 628 _LIBCPP_SUPPRESS_DEPRECATED_POP 629 typedef bool __result_type; // used by valarray 630 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 631 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 632 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 633 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 634 #endif 635 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 636 bool operator()(const _Tp& __x, const _Tp& __y) const 637 {return __x && __y;} 638 }; 639 640 #if _LIBCPP_STD_VER > 11 641 template <> 642 struct _LIBCPP_TEMPLATE_VIS logical_and<void> 643 { 644 template <class _T1, class _T2> 645 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 646 auto operator()(_T1&& __t, _T2&& __u) const 647 noexcept(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))) 648 -> decltype( _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)) 649 { return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); } 650 typedef void is_transparent; 651 }; 652 #endif 653 654 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 655 #if _LIBCPP_STD_VER > 11 656 template <class _Tp = void> 657 #else 658 template <class _Tp> 659 #endif 660 struct _LIBCPP_TEMPLATE_VIS logical_not 661 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 662 : unary_function<_Tp, bool> 663 #endif 664 { 665 _LIBCPP_SUPPRESS_DEPRECATED_POP 666 typedef bool __result_type; // used by valarray 667 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 668 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 669 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp argument_type; 670 #endif 671 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 672 bool operator()(const _Tp& __x) const 673 {return !__x;} 674 }; 675 676 #if _LIBCPP_STD_VER > 11 677 template <> 678 struct _LIBCPP_TEMPLATE_VIS logical_not<void> 679 { 680 template <class _Tp> 681 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 682 auto operator()(_Tp&& __x) const 683 noexcept(noexcept(!_VSTD::forward<_Tp>(__x))) 684 -> decltype( !_VSTD::forward<_Tp>(__x)) 685 { return !_VSTD::forward<_Tp>(__x); } 686 typedef void is_transparent; 687 }; 688 #endif 689 690 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 691 #if _LIBCPP_STD_VER > 11 692 template <class _Tp = void> 693 #else 694 template <class _Tp> 695 #endif 696 struct _LIBCPP_TEMPLATE_VIS logical_or 697 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES) 698 : binary_function<_Tp, _Tp, bool> 699 #endif 700 { 701 _LIBCPP_SUPPRESS_DEPRECATED_POP 702 typedef bool __result_type; // used by valarray 703 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS) 704 _LIBCPP_DEPRECATED_IN_CXX17 typedef bool result_type; 705 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp first_argument_type; 706 _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp second_argument_type; 707 #endif 708 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 709 bool operator()(const _Tp& __x, const _Tp& __y) const 710 {return __x || __y;} 711 }; 712 713 #if _LIBCPP_STD_VER > 11 714 template <> 715 struct _LIBCPP_TEMPLATE_VIS logical_or<void> 716 { 717 template <class _T1, class _T2> 718 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 719 auto operator()(_T1&& __t, _T2&& __u) const 720 noexcept(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))) 721 -> decltype( _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)) 722 { return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); } 723 typedef void is_transparent; 724 }; 725 #endif 726 727 _LIBCPP_END_NAMESPACE_STD 728 729 #endif // _LIBCPP___FUNCTIONAL_OPERATIONS_H 730