Changeset db54a9d in mainline for uspace/lib/cpp/include/impl/functional.hpp
- Timestamp:
- 2018-07-05T21:41:23Z (7 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- baed175
- Parents:
- f509d40
- git-author:
- Dzejrou <dzejrou@…> (2018-05-09 23:05:44)
- git-committer:
- Dzejrou <dzejrou@…> (2018-07-05 21:41:23)
- File:
-
- 1 edited
-
uspace/lib/cpp/include/impl/functional.hpp (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/cpp/include/impl/functional.hpp
rf509d40 rdb54a9d 50 50 51 51 /** 52 * 20.9.5, arithmetic operations:53 */54 55 template<class T = void>56 struct plus57 {58 constexpr T operator()(const T& lhs, const T& rhs) const59 {60 return lhs + rhs;61 }62 63 using first_argument_type = T;64 using second_argument_type = T;65 using result_type = T;66 };67 68 template<class T = void>69 struct minus70 {71 constexpr T operator()(const T& lhs, const T& rhs) const72 {73 return lhs - rhs;74 }75 76 using first_argument_type = T;77 using second_argument_type = T;78 using result_type = T;79 };80 81 template<class T = void>82 struct multiplies83 {84 constexpr T operator()(const T& lhs, const T& rhs) const85 {86 return lhs * rhs;87 }88 89 using first_argument_type = T;90 using second_argument_type = T;91 using result_type = T;92 };93 94 template<class T = void>95 struct divides96 {97 constexpr T operator()(const T& lhs, const T& rhs) const98 {99 return lhs / rhs;100 }101 102 using first_argument_type = T;103 using second_argument_type = T;104 using result_type = T;105 };106 107 template<class T = void>108 struct modulus109 {110 constexpr T operator()(const T& lhs, const T& rhs) const111 {112 return lhs % rhs;113 }114 115 using first_argument_type = T;116 using second_argument_type = T;117 using result_type = T;118 };119 120 template<class T = void>121 struct negate122 {123 constexpr T operator()(const T& x) const124 {125 return -x;126 }127 128 using argument_type = T;129 using result_type = T;130 };131 132 namespace aux133 {134 /**135 * Used by some functions like std::set::find to determine136 * whether a functor is transparent.137 */138 struct transparent_t;139 140 template<class T, class = void>141 struct is_transparent: false_type142 { /* DUMMY BODY */ };143 144 template<class T>145 struct is_transparent<T, void_t<typename T::is_transparent>>146 : true_type147 { /* DUMMY BODY */ };148 149 template<class T>150 inline constexpr bool is_transparent_v = is_transparent<T>::value;151 }152 153 template<>154 struct plus<void>155 {156 template<class T, class U>157 constexpr auto operator()(T&& lhs, U&& rhs) const158 -> decltype(forward<T>(lhs) + forward<U>(rhs))159 {160 return forward<T>(lhs) + forward<T>(rhs);161 }162 163 using is_transparent = aux::transparent_t;164 };165 166 template<>167 struct minus<void>168 {169 template<class T, class U>170 constexpr auto operator()(T&& lhs, U&& rhs) const171 -> decltype(forward<T>(lhs) - forward<U>(rhs))172 {173 return forward<T>(lhs) - forward<T>(rhs);174 }175 176 using is_transparent = aux::transparent_t;177 };178 179 template<>180 struct multiplies<void>181 {182 template<class T, class U>183 constexpr auto operator()(T&& lhs, U&& rhs) const184 -> decltype(forward<T>(lhs) * forward<U>(rhs))185 {186 return forward<T>(lhs) * forward<T>(rhs);187 }188 189 using is_transparent = aux::transparent_t;190 };191 192 template<>193 struct divides<void>194 {195 template<class T, class U>196 constexpr auto operator()(T&& lhs, U&& rhs) const197 -> decltype(forward<T>(lhs) / forward<U>(rhs))198 {199 return forward<T>(lhs) / forward<T>(rhs);200 }201 202 using is_transparent = aux::transparent_t;203 };204 205 template<>206 struct modulus<void>207 {208 template<class T, class U>209 constexpr auto operator()(T&& lhs, U&& rhs) const210 -> decltype(forward<T>(lhs) % forward<U>(rhs))211 {212 return forward<T>(lhs) % forward<T>(rhs);213 }214 215 using is_transparent = aux::transparent_t;216 };217 218 template<>219 struct negate<void>220 {221 template<class T>222 constexpr auto operator()(T&& x) const223 -> decltype(-forward<T>(x))224 {225 return -forward<T>(x);226 }227 228 using is_transparent = aux::transparent_t;229 };230 231 /**232 * 20.9.6, comparisons:233 */234 235 template<class T = void>236 struct equal_to237 {238 constexpr bool operator()(const T& lhs, const T& rhs) const239 {240 return lhs == rhs;241 }242 243 using first_argument_type = T;244 using second_argument_type = T;245 using result_type = bool;246 };247 248 template<class T = void>249 struct not_equal_to250 {251 constexpr bool operator()(const T& lhs, const T& rhs) const252 {253 return lhs != rhs;254 }255 256 using first_argument_type = T;257 using second_argument_type = T;258 using result_type = bool;259 };260 261 template<class T = void>262 struct greater263 {264 constexpr bool operator()(const T& lhs, const T& rhs) const265 {266 return lhs > rhs;267 }268 269 using first_argument_type = T;270 using second_argument_type = T;271 using result_type = bool;272 };273 274 template<class T = void>275 struct less276 {277 constexpr bool operator()(const T& lhs, const T& rhs) const278 {279 return lhs < rhs;280 }281 282 using first_argument_type = T;283 using second_argument_type = T;284 using result_type = bool;285 };286 287 template<class T = void>288 struct greater_equal289 {290 constexpr bool operator()(const T& lhs, const T& rhs) const291 {292 return lhs >= rhs;293 }294 295 using first_argument_type = T;296 using second_argument_type = T;297 using result_type = bool;298 };299 300 template<class T = void>301 struct less_equal302 {303 constexpr bool operator()(const T& lhs, const T& rhs) const304 {305 return lhs <= rhs;306 }307 308 using first_argument_type = T;309 using second_argument_type = T;310 using result_type = bool;311 };312 313 template<>314 struct equal_to<void>315 {316 template<class T, class U>317 constexpr auto operator()(T&& lhs, U&& rhs) const318 -> decltype(forward<T>(lhs) == forward<U>(rhs))319 {320 return forward<T>(lhs) == forward<U>(rhs);321 }322 323 using is_transparent = aux::transparent_t;324 };325 326 template<>327 struct not_equal_to<void>328 {329 template<class T, class U>330 constexpr auto operator()(T&& lhs, U&& rhs) const331 -> decltype(forward<T>(lhs) != forward<U>(rhs))332 {333 return forward<T>(lhs) != forward<U>(rhs);334 }335 336 using is_transparent = aux::transparent_t;337 };338 339 template<>340 struct greater<void>341 {342 template<class T, class U>343 constexpr auto operator()(T&& lhs, U&& rhs) const344 -> decltype(forward<T>(lhs) > forward<U>(rhs))345 {346 return forward<T>(lhs) > forward<U>(rhs);347 }348 349 using is_transparent = aux::transparent_t;350 };351 352 template<>353 struct less<void>354 {355 template<class T, class U>356 constexpr auto operator()(T&& lhs, U&& rhs) const357 -> decltype(forward<T>(lhs) < forward<U>(rhs))358 {359 return forward<T>(lhs) < forward<U>(rhs);360 }361 362 using is_transparent = aux::transparent_t;363 };364 365 template<>366 struct greater_equal<void>367 {368 template<class T, class U>369 constexpr auto operator()(T&& lhs, U&& rhs) const370 -> decltype(forward<T>(lhs) >= forward<U>(rhs))371 {372 return forward<T>(lhs) >= forward<U>(rhs);373 }374 375 using is_transparent = aux::transparent_t;376 };377 378 template<>379 struct less_equal<void>380 {381 template<class T, class U>382 constexpr auto operator()(T&& lhs, U&& rhs) const383 -> decltype(forward<T>(lhs) <= forward<U>(rhs))384 {385 return forward<T>(lhs) <= forward<U>(rhs);386 }387 388 using is_transparent = aux::transparent_t;389 };390 391 /**392 * 20.9.7, logical operations:393 */394 395 template<class T = void>396 struct logical_and397 {398 constexpr bool operator()(const T& lhs, const T& rhs) const399 {400 return lhs && rhs;401 }402 403 using first_argument_type = T;404 using second_argument_type = T;405 using result_type = bool;406 };407 408 template<class T = void>409 struct logical_or410 {411 constexpr bool operator()(const T& lhs, const T& rhs) const412 {413 return lhs || rhs;414 }415 416 using first_argument_type = T;417 using second_argument_type = T;418 using result_type = bool;419 };420 421 template<class T = void>422 struct logical_not423 {424 constexpr bool operator()(const T& x) const425 {426 return !x;427 }428 429 using argument_type = T;430 using result_type = bool;431 };432 433 template<>434 struct logical_and<void>435 {436 template<class T, class U>437 constexpr auto operator()(T&& lhs, U&& rhs) const438 -> decltype(forward<T>(lhs) && forward<U>(rhs))439 {440 return forward<T>(lhs) && forward<U>(rhs);441 }442 443 using is_transparent = aux::transparent_t;444 };445 446 template<>447 struct logical_or<void>448 {449 template<class T, class U>450 constexpr auto operator()(T&& lhs, U&& rhs) const451 -> decltype(forward<T>(lhs) || forward<U>(rhs))452 {453 return forward<T>(lhs) || forward<U>(rhs);454 }455 456 using is_transparent = aux::transparent_t;457 };458 459 template<>460 struct logical_not<void>461 {462 template<class T>463 constexpr auto operator()(T&& x) const464 -> decltype(!forward<T>(x))465 {466 return !forward<T>(x);467 }468 469 using is_transparent = aux::transparent_t;470 };471 472 /**473 * 20.9.8, bitwise operations:474 */475 476 template<class T = void>477 struct bit_and478 {479 constexpr T operator()(const T& lhs, const T& rhs) const480 {481 return lhs & rhs;482 }483 484 using first_argument_type = T;485 using second_argument_type = T;486 using result_type = T;487 };488 489 template<class T = void>490 struct bit_or491 {492 constexpr T operator()(const T& lhs, const T& rhs) const493 {494 return lhs | rhs;495 }496 497 using first_argument_type = T;498 using second_argument_type = T;499 using result_type = T;500 };501 502 template<class T = void>503 struct bit_xor504 {505 constexpr T operator()(const T& lhs, const T& rhs) const506 {507 return lhs ^ rhs;508 }509 510 using first_argument_type = T;511 using second_argument_type = T;512 using result_type = T;513 };514 515 template<class T = void>516 struct bit_not517 {518 constexpr bool operator()(const T& x) const519 {520 return ~x;521 }522 523 using argument_type = T;524 using result_type = T;525 };526 527 template<>528 struct bit_and<void>529 {530 template<class T, class U>531 constexpr auto operator()(T&& lhs, U&& rhs) const532 -> decltype(forward<T>(lhs) & forward<U>(rhs))533 {534 return forward<T>(lhs) & forward<U>(rhs);535 }536 537 using is_transparent = aux::transparent_t;538 };539 540 template<>541 struct bit_or<void>542 {543 template<class T, class U>544 constexpr auto operator()(T&& lhs, U&& rhs) const545 -> decltype(forward<T>(lhs) | forward<U>(rhs))546 {547 return forward<T>(lhs) | forward<U>(rhs);548 }549 550 using is_transparent = aux::transparent_t;551 };552 553 template<>554 struct bit_xor<void>555 {556 template<class T, class U>557 constexpr auto operator()(T&& lhs, U&& rhs) const558 -> decltype(forward<T>(lhs) ^ forward<U>(rhs))559 {560 return forward<T>(lhs) ^ forward<U>(rhs);561 }562 563 using is_transparent = aux::transparent_t;564 };565 566 template<>567 struct bit_not<void>568 {569 template<class T>570 constexpr auto operator()(T&& x) const571 -> decltype(~forward<T>(x))572 {573 return ~forward<T>(x);574 }575 576 using is_transparent = aux::transparent_t;577 };578 579 /**580 * 20.9.9, negators:581 */582 583 template<class Predicate>584 class unary_negate585 {586 public:587 using result_type = bool;588 using argument_type = typename Predicate::argument_type;589 590 constexpr explicit unary_negate(const Predicate& pred)591 : pred_{pred}592 { /* DUMMY BODY */ }593 594 constexpr result_type operator()(const argument_type& arg)595 {596 return !pred_(arg);597 }598 599 private:600 Predicate pred_;601 };602 603 template<class Predicate>604 constexpr unary_negate<Predicate> not1(const Predicate& pred)605 {606 return unary_negate<Predicate>{pred};607 }608 609 template<class Predicate>610 class binary_negate611 {612 public:613 using result_type = bool;614 using first_argument_type = typename Predicate::first_argument_type;615 using second_argument_type = typename Predicate::second_argument_type;616 617 constexpr explicit binary_negate(const Predicate& pred)618 : pred_{pred}619 { /* DUMMY BODY */ }620 621 constexpr result_type operator()(const first_argument_type& arg1,622 const second_argument_type& arg2)623 {624 return !pred_(arg1, arg2);625 }626 627 private:628 Predicate pred_;629 };630 631 template<class Predicate>632 constexpr binary_negate<Predicate> not2(const Predicate& pred);633 634 /**635 52 * 20.9.11, member function adaptors: 636 53 */
Note:
See TracChangeset
for help on using the changeset viewer.
