API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 15th, 2019
112
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 32.55 KB | None | 0 0
raw download clone embed print report
  1. // Functor implementations -*- C++ -*-
  2.  
  3. // Copyright (C) 2001-2014 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library. This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /*
  26. *
  27. * Copyright (c) 1994
  28. * Hewlett-Packard Company
  29. *
  30. * Permission to use, copy, modify, distribute and sell this software
  31. * and its documentation for any purpose is hereby granted without fee,
  32. * provided that the above copyright notice appear in all copies and
  33. * that both that copyright notice and this permission notice appear
  34. * in supporting documentation. Hewlett-Packard Company makes no
  35. * representations about the suitability of this software for any
  36. * purpose. It is provided "as is" without express or implied warranty.
  37. *
  38. *
  39. * Copyright (c) 1996-1998
  40. * Silicon Graphics Computer Systems, Inc.
  41. *
  42. * Permission to use, copy, modify, distribute and sell this software
  43. * and its documentation for any purpose is hereby granted without fee,
  44. * provided that the above copyright notice appear in all copies and
  45. * that both that copyright notice and this permission notice appear
  46. * in supporting documentation. Silicon Graphics makes no
  47. * representations about the suitability of this software for any
  48. * purpose. It is provided "as is" without express or implied warranty.
  49. */
  50.  
  51. /** @file bits/stl_function.h
  52. * This is an internal header file, included by other library headers.
  53. * Do not attempt to use it directly. @headername{functional}
  54. */
  55.  
  56. #ifndef _STL_FUNCTION_H
  57. #define _STL_FUNCTION_H 1
  58.  
  59. #if __cplusplus > 201103L
  60. #include <bits/move.h>
  61. #endif
  62.  
  63. namespace std _GLIBCXX_VISIBILITY(default)
  64. {
  65. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  66.  
  67. // 20.3.1 base classes
  68. /** @defgroup functors Function Objects
  69. * @ingroup utilities
  70. *
  71. * Function objects, or @e functors, are objects with an @c operator()
  72. * defined and accessible. They can be passed as arguments to algorithm
  73. * templates and used in place of a function pointer. Not only is the
  74. * resulting expressiveness of the library increased, but the generated
  75. * code can be more efficient than what you might write by hand. When we
  76. * refer to @a functors, then, generally we include function pointers in
  77. * the description as well.
  78. *
  79. * Often, functors are only created as temporaries passed to algorithm
  80. * calls, rather than being created as named variables.
  81. *
  82. * Two examples taken from the standard itself follow. To perform a
  83. * by-element addition of two vectors @c a and @c b containing @c double,
  84. * and put the result in @c a, use
  85. * \code
  86. * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
  87. * \endcode
  88. * To negate every element in @c a, use
  89. * \code
  90. * transform(a.begin(), a.end(), a.begin(), negate<double>());
  91. * \endcode
  92. * The addition and negation functions will be inlined directly.
  93. *
  94. * The standard functors are derived from structs named @c unary_function
  95. * and @c binary_function. These two classes contain nothing but typedefs,
  96. * to aid in generic (template) programming. If you write your own
  97. * functors, you might consider doing the same.
  98. *
  99. * @{
  100. */
  101. /**
  102. * This is one of the @link functors functor base classes@endlink.
  103. */
  104. template<typename _Arg, typename _Result>
  105. struct unary_function
  106. {
  107. /// @c argument_type is the type of the argument
  108. typedef _Arg argument_type;
  109.  
  110. /// @c result_type is the return type
  111. typedef _Result result_type;
  112. };
  113.  
  114. /**
  115. * This is one of the @link functors functor base classes@endlink.
  116. */
  117. template<typename _Arg1, typename _Arg2, typename _Result>
  118. struct binary_function
  119. {
  120. /// @c first_argument_type is the type of the first argument
  121. typedef _Arg1 first_argument_type;
  122.  
  123. /// @c second_argument_type is the type of the second argument
  124. typedef _Arg2 second_argument_type;
  125.  
  126. /// @c result_type is the return type
  127. typedef _Result result_type;
  128. };
  129. /** @} */
  130.  
  131. // 20.3.2 arithmetic
  132. /** @defgroup arithmetic_functors Arithmetic Classes
  133. * @ingroup functors
  134. *
  135. * Because basic math often needs to be done during an algorithm,
  136. * the library provides functors for those operations. See the
  137. * documentation for @link functors the base classes@endlink
  138. * for examples of their use.
  139. *
  140. * @{
  141. */
  142.  
  143. #if __cplusplus > 201103L
  144. struct __is_transparent; // undefined
  145.  
  146. template<typename _Tp = void>
  147. struct plus;
  148.  
  149. template<typename _Tp = void>
  150. struct minus;
  151.  
  152. template<typename _Tp = void>
  153. struct multiplies;
  154.  
  155. template<typename _Tp = void>
  156. struct divides;
  157.  
  158. template<typename _Tp = void>
  159. struct modulus;
  160.  
  161. template<typename _Tp = void>
  162. struct negate;
  163. #endif
  164.  
  165. /// One of the @link arithmetic_functors math functors@endlink.
  166. template<typename _Tp>
  167. struct plus : public binary_function<_Tp, _Tp, _Tp>
  168. {
  169. _Tp
  170. operator()(const _Tp& __x, const _Tp& __y) const
  171. { return __x + __y; }
  172. };
  173.  
  174. /// One of the @link arithmetic_functors math functors@endlink.
  175. template<typename _Tp>
  176. struct minus : public binary_function<_Tp, _Tp, _Tp>
  177. {
  178. _Tp
  179. operator()(const _Tp& __x, const _Tp& __y) const
  180. { return __x - __y; }
  181. };
  182.  
  183. /// One of the @link arithmetic_functors math functors@endlink.
  184. template<typename _Tp>
  185. struct multiplies : public binary_function<_Tp, _Tp, _Tp>
  186. {
  187. _Tp
  188. operator()(const _Tp& __x, const _Tp& __y) const
  189. { return __x * __y; }
  190. };
  191.  
  192. /// One of the @link arithmetic_functors math functors@endlink.
  193. template<typename _Tp>
  194. struct divides : public binary_function<_Tp, _Tp, _Tp>
  195. {
  196. _Tp
  197. operator()(const _Tp& __x, const _Tp& __y) const
  198. { return __x / __y; }
  199. };
  200.  
  201. /// One of the @link arithmetic_functors math functors@endlink.
  202. template<typename _Tp>
  203. struct modulus : public binary_function<_Tp, _Tp, _Tp>
  204. {
  205. _Tp
  206. operator()(const _Tp& __x, const _Tp& __y) const
  207. { return __x % __y; }
  208. };
  209.  
  210. /// One of the @link arithmetic_functors math functors@endlink.
  211. template<typename _Tp>
  212. struct negate : public unary_function<_Tp, _Tp>
  213. {
  214. _Tp
  215. operator()(const _Tp& __x) const
  216. { return -__x; }
  217. };
  218.  
  219. #if __cplusplus > 201103L
  220.  
  221. #define __cpp_lib_transparent_operators 201210
  222. //#define __cpp_lib_generic_associative_lookup 201304
  223.  
  224. template<>
  225. struct plus<void>
  226. {
  227. template <typename _Tp, typename _Up>
  228. auto
  229. operator()(_Tp&& __t, _Up&& __u) const
  230. noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
  231. -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
  232. { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
  233.  
  234. typedef __is_transparent is_transparent;
  235. };
  236.  
  237. /// One of the @link arithmetic_functors math functors@endlink.
  238. template<>
  239. struct minus<void>
  240. {
  241. template <typename _Tp, typename _Up>
  242. auto
  243. operator()(_Tp&& __t, _Up&& __u) const
  244. noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
  245. -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
  246. { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
  247.  
  248. typedef __is_transparent is_transparent;
  249. };
  250.  
  251. /// One of the @link arithmetic_functors math functors@endlink.
  252. template<>
  253. struct multiplies<void>
  254. {
  255. template <typename _Tp, typename _Up>
  256. auto
  257. operator()(_Tp&& __t, _Up&& __u) const
  258. noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
  259. -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
  260. { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
  261.  
  262. typedef __is_transparent is_transparent;
  263. };
  264.  
  265. /// One of the @link arithmetic_functors math functors@endlink.
  266. template<>
  267. struct divides<void>
  268. {
  269. template <typename _Tp, typename _Up>
  270. auto
  271. operator()(_Tp&& __t, _Up&& __u) const
  272. noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
  273. -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
  274. { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
  275.  
  276. typedef __is_transparent is_transparent;
  277. };
  278.  
  279. /// One of the @link arithmetic_functors math functors@endlink.
  280. template<>
  281. struct modulus<void>
  282. {
  283. template <typename _Tp, typename _Up>
  284. auto
  285. operator()(_Tp&& __t, _Up&& __u) const
  286. noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
  287. -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
  288. { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
  289.  
  290. typedef __is_transparent is_transparent;
  291. };
  292.  
  293. /// One of the @link arithmetic_functors math functors@endlink.
  294. template<>
  295. struct negate<void>
  296. {
  297. template <typename _Tp>
  298. auto
  299. operator()(_Tp&& __t) const
  300. noexcept(noexcept(-std::forward<_Tp>(__t)))
  301. -> decltype(-std::forward<_Tp>(__t))
  302. { return -std::forward<_Tp>(__t); }
  303.  
  304. typedef __is_transparent is_transparent;
  305. };
  306. #endif
  307. /** @} */
  308.  
  309. // 20.3.3 comparisons
  310. /** @defgroup comparison_functors Comparison Classes
  311. * @ingroup functors
  312. *
  313. * The library provides six wrapper functors for all the basic comparisons
  314. * in C++, like @c <.
  315. *
  316. * @{
  317. */
  318. #if __cplusplus > 201103L
  319. template<typename _Tp = void>
  320. struct equal_to;
  321.  
  322. template<typename _Tp = void>
  323. struct not_equal_to;
  324.  
  325. template<typename _Tp = void>
  326. struct greater;
  327.  
  328. template<typename _Tp = void>
  329. struct less;
  330.  
  331. template<typename _Tp = void>
  332. struct greater_equal;
  333.  
  334. template<typename _Tp = void>
  335. struct less_equal;
  336. #endif
  337.  
  338. /// One of the @link comparison_functors comparison functors@endlink.
  339. template<typename _Tp>
  340. struct equal_to : public binary_function<_Tp, _Tp, bool>
  341. {
  342. bool
  343. operator()(const _Tp& __x, const _Tp& __y) const
  344. { return __x == __y; }
  345. };
  346.  
  347. /// One of the @link comparison_functors comparison functors@endlink.
  348. template<typename _Tp>
  349. struct not_equal_to : public binary_function<_Tp, _Tp, bool>
  350. {
  351. bool
  352. operator()(const _Tp& __x, const _Tp& __y) const
  353. { return __x != __y; }
  354. };
  355.  
  356. /// One of the @link comparison_functors comparison functors@endlink.
  357. template<typename _Tp>
  358. struct greater : public binary_function<_Tp, _Tp, bool>
  359. {
  360. bool
  361. operator()(const _Tp& __x, const _Tp& __y) const
  362. { return __x > __y; }
  363. };
  364.  
  365. /// One of the @link comparison_functors comparison functors@endlink.
  366. template<typename _Tp>
  367. struct less : public binary_function<_Tp, _Tp, bool>
  368. {
  369. bool
  370. operator()(const _Tp& __x, const _Tp& __y) const
  371. { return __x < __y; }
  372. };
  373.  
  374. /// One of the @link comparison_functors comparison functors@endlink.
  375. template<typename _Tp>
  376. struct greater_equal : public binary_function<_Tp, _Tp, bool>
  377. {
  378. bool
  379. operator()(const _Tp& __x, const _Tp& __y) const
  380. { return __x >= __y; }
  381. };
  382.  
  383. /// One of the @link comparison_functors comparison functors@endlink.
  384. template<typename _Tp>
  385. struct less_equal : public binary_function<_Tp, _Tp, bool>
  386. {
  387. bool
  388. operator()(const _Tp& __x, const _Tp& __y) const
  389. { return __x <= __y; }
  390. };
  391.  
  392. #if __cplusplus > 201103L
  393. /// One of the @link comparison_functors comparison functors@endlink.
  394. template<>
  395. struct equal_to<void>
  396. {
  397. template <typename _Tp, typename _Up>
  398. auto
  399. operator()(_Tp&& __t, _Up&& __u) const
  400. noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
  401. -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
  402. { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
  403.  
  404. typedef __is_transparent is_transparent;
  405. };
  406.  
  407. /// One of the @link comparison_functors comparison functors@endlink.
  408. template<>
  409. struct not_equal_to<void>
  410. {
  411. template <typename _Tp, typename _Up>
  412. auto
  413. operator()(_Tp&& __t, _Up&& __u) const
  414. noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
  415. -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
  416. { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
  417.  
  418. typedef __is_transparent is_transparent;
  419. };
  420.  
  421. /// One of the @link comparison_functors comparison functors@endlink.
  422. template<>
  423. struct greater<void>
  424. {
  425. template <typename _Tp, typename _Up>
  426. auto
  427. operator()(_Tp&& __t, _Up&& __u) const
  428. noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
  429. -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
  430. { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
  431.  
  432. typedef __is_transparent is_transparent;
  433. };
  434.  
  435. /// One of the @link comparison_functors comparison functors@endlink.
  436. template<>
  437. struct less<void>
  438. {
  439. template <typename _Tp, typename _Up>
  440. auto
  441. operator()(_Tp&& __t, _Up&& __u) const
  442. noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
  443. -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
  444. { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
  445.  
  446. typedef __is_transparent is_transparent;
  447. };
  448.  
  449. /// One of the @link comparison_functors comparison functors@endlink.
  450. template<>
  451. struct greater_equal<void>
  452. {
  453. template <typename _Tp, typename _Up>
  454. auto
  455. operator()(_Tp&& __t, _Up&& __u) const
  456. noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
  457. -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
  458. { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
  459.  
  460. typedef __is_transparent is_transparent;
  461. };
  462.  
  463. /// One of the @link comparison_functors comparison functors@endlink.
  464. template<>
  465. struct less_equal<void>
  466. {
  467. template <typename _Tp, typename _Up>
  468. auto
  469. operator()(_Tp&& __t, _Up&& __u) const
  470. noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
  471. -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
  472. { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
  473.  
  474. typedef __is_transparent is_transparent;
  475. };
  476. #endif
  477. /** @} */
  478.  
  479. // 20.3.4 logical operations
  480. /** @defgroup logical_functors Boolean Operations Classes
  481. * @ingroup functors
  482. *
  483. * Here are wrapper functors for Boolean operations: @c &&, @c ||,
  484. * and @c !.
  485. *
  486. * @{
  487. */
  488. #if __cplusplus > 201103L
  489. template<typename _Tp = void>
  490. struct logical_and;
  491.  
  492. template<typename _Tp = void>
  493. struct logical_or;
  494.  
  495. template<typename _Tp = void>
  496. struct logical_not;
  497. #endif
  498.  
  499. /// One of the @link logical_functors Boolean operations functors@endlink.
  500. template<typename _Tp>
  501. struct logical_and : public binary_function<_Tp, _Tp, bool>
  502. {
  503. bool
  504. operator()(const _Tp& __x, const _Tp& __y) const
  505. { return __x && __y; }
  506. };
  507.  
  508. /// One of the @link logical_functors Boolean operations functors@endlink.
  509. template<typename _Tp>
  510. struct logical_or : public binary_function<_Tp, _Tp, bool>
  511. {
  512. bool
  513. operator()(const _Tp& __x, const _Tp& __y) const
  514. { return __x || __y; }
  515. };
  516.  
  517. /// One of the @link logical_functors Boolean operations functors@endlink.
  518. template<typename _Tp>
  519. struct logical_not : public unary_function<_Tp, bool>
  520. {
  521. bool
  522. operator()(const _Tp& __x) const
  523. { return !__x; }
  524. };
  525.  
  526. #if __cplusplus > 201103L
  527. /// One of the @link logical_functors Boolean operations functors@endlink.
  528. template<>
  529. struct logical_and<void>
  530. {
  531. template <typename _Tp, typename _Up>
  532. auto
  533. operator()(_Tp&& __t, _Up&& __u) const
  534. noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
  535. -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
  536. { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
  537.  
  538. typedef __is_transparent is_transparent;
  539. };
  540.  
  541. /// One of the @link logical_functors Boolean operations functors@endlink.
  542. template<>
  543. struct logical_or<void>
  544. {
  545. template <typename _Tp, typename _Up>
  546. auto
  547. operator()(_Tp&& __t, _Up&& __u) const
  548. noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
  549. -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
  550. { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
  551.  
  552. typedef __is_transparent is_transparent;
  553. };
  554.  
  555. /// One of the @link logical_functors Boolean operations functors@endlink.
  556. template<>
  557. struct logical_not<void>
  558. {
  559. template <typename _Tp>
  560. auto
  561. operator()(_Tp&& __t) const
  562. noexcept(noexcept(!std::forward<_Tp>(__t)))
  563. -> decltype(!std::forward<_Tp>(__t))
  564. { return !std::forward<_Tp>(__t); }
  565.  
  566. typedef __is_transparent is_transparent;
  567. };
  568. #endif
  569. /** @} */
  570.  
  571. #if __cplusplus > 201103L
  572. template<typename _Tp = void>
  573. struct bit_and;
  574.  
  575. template<typename _Tp = void>
  576. struct bit_or;
  577.  
  578. template<typename _Tp = void>
  579. struct bit_xor;
  580.  
  581. template<typename _Tp = void>
  582. struct bit_not;
  583. #endif
  584.  
  585. // _GLIBCXX_RESOLVE_LIB_DEFECTS
  586. // DR 660. Missing Bitwise Operations.
  587. template<typename _Tp>
  588. struct bit_and : public binary_function<_Tp, _Tp, _Tp>
  589. {
  590. _Tp
  591. operator()(const _Tp& __x, const _Tp& __y) const
  592. { return __x & __y; }
  593. };
  594.  
  595. template<typename _Tp>
  596. struct bit_or : public binary_function<_Tp, _Tp, _Tp>
  597. {
  598. _Tp
  599. operator()(const _Tp& __x, const _Tp& __y) const
  600. { return __x | __y; }
  601. };
  602.  
  603. template<typename _Tp>
  604. struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
  605. {
  606. _Tp
  607. operator()(const _Tp& __x, const _Tp& __y) const
  608. { return __x ^ __y; }
  609. };
  610.  
  611. template<typename _Tp>
  612. struct bit_not : public unary_function<_Tp, _Tp>
  613. {
  614. _Tp
  615. operator()(const _Tp& __x) const
  616. { return ~__x; }
  617. };
  618.  
  619. #if __cplusplus > 201103L
  620. template <>
  621. struct bit_and<void>
  622. {
  623. template <typename _Tp, typename _Up>
  624. auto
  625. operator()(_Tp&& __t, _Up&& __u) const
  626. noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
  627. -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
  628. { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
  629.  
  630. typedef __is_transparent is_transparent;
  631. };
  632.  
  633. template <>
  634. struct bit_or<void>
  635. {
  636. template <typename _Tp, typename _Up>
  637. auto
  638. operator()(_Tp&& __t, _Up&& __u) const
  639. noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
  640. -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
  641. { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
  642.  
  643. typedef __is_transparent is_transparent;
  644. };
  645.  
  646. template <>
  647. struct bit_xor<void>
  648. {
  649. template <typename _Tp, typename _Up>
  650. auto
  651. operator()(_Tp&& __t, _Up&& __u) const
  652. noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
  653. -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
  654. { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
  655.  
  656. typedef __is_transparent is_transparent;
  657. };
  658.  
  659. template <>
  660. struct bit_not<void>
  661. {
  662. template <typename _Tp>
  663. auto
  664. operator()(_Tp&& __t) const
  665. noexcept(noexcept(~std::forward<_Tp>(__t)))
  666. -> decltype(~std::forward<_Tp>(__t))
  667. { return ~std::forward<_Tp>(__t); }
  668.  
  669. typedef __is_transparent is_transparent;
  670. };
  671. #endif
  672.  
  673. // 20.3.5 negators
  674. /** @defgroup negators Negators
  675. * @ingroup functors
  676. *
  677. * The functions @c not1 and @c not2 each take a predicate functor
  678. * and return an instance of @c unary_negate or
  679. * @c binary_negate, respectively. These classes are functors whose
  680. * @c operator() performs the stored predicate function and then returns
  681. * the negation of the result.
  682. *
  683. * For example, given a vector of integers and a trivial predicate,
  684. * \code
  685. * struct IntGreaterThanThree
  686. * : public std::unary_function<int, bool>
  687. * {
  688. * bool operator() (int x) { return x > 3; }
  689. * };
  690. *
  691. * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
  692. * \endcode
  693. * The call to @c find_if will locate the first index (i) of @c v for which
  694. * <code>!(v[i] > 3)</code> is true.
  695. *
  696. * The not1/unary_negate combination works on predicates taking a single
  697. * argument. The not2/binary_negate combination works on predicates which
  698. * take two arguments.
  699. *
  700. * @{
  701. */
  702. /// One of the @link negators negation functors@endlink.
  703. template<typename _Predicate>
  704. class unary_negate
  705. : public unary_function<typename _Predicate::argument_type, bool>
  706. {
  707. protected:
  708. _Predicate _M_pred;
  709.  
  710. public:
  711. explicit
  712. unary_negate(const _Predicate& __x) : _M_pred(__x) { }
  713.  
  714. bool
  715. operator()(const typename _Predicate::argument_type& __x) const
  716. { return !_M_pred(__x); }
  717. };
  718.  
  719. /// One of the @link negators negation functors@endlink.
  720. template<typename _Predicate>
  721. inline unary_negate<_Predicate>
  722. not1(const _Predicate& __pred)
  723. { return unary_negate<_Predicate>(__pred); }
  724.  
  725. /// One of the @link negators negation functors@endlink.
  726. template<typename _Predicate>
  727. class binary_negate
  728. : public binary_function<typename _Predicate::first_argument_type,
  729. typename _Predicate::second_argument_type, bool>
  730. {
  731. protected:
  732. _Predicate _M_pred;
  733.  
  734. public:
  735. explicit
  736. binary_negate(const _Predicate& __x) : _M_pred(__x) { }
  737.  
  738. bool
  739. operator()(const typename _Predicate::first_argument_type& __x,
  740. const typename _Predicate::second_argument_type& __y) const
  741. { return !_M_pred(__x, __y); }
  742. };
  743.  
  744. /// One of the @link negators negation functors@endlink.
  745. template<typename _Predicate>
  746. inline binary_negate<_Predicate>
  747. not2(const _Predicate& __pred)
  748. { return binary_negate<_Predicate>(__pred); }
  749. /** @} */
  750.  
  751. // 20.3.7 adaptors pointers functions
  752. /** @defgroup pointer_adaptors Adaptors for pointers to functions
  753. * @ingroup functors
  754. *
  755. * The advantage of function objects over pointers to functions is that
  756. * the objects in the standard library declare nested typedefs describing
  757. * their argument and result types with uniform names (e.g., @c result_type
  758. * from the base classes @c unary_function and @c binary_function).
  759. * Sometimes those typedefs are required, not just optional.
  760. *
  761. * Adaptors are provided to turn pointers to unary (single-argument) and
  762. * binary (double-argument) functions into function objects. The
  763. * long-winded functor @c pointer_to_unary_function is constructed with a
  764. * function pointer @c f, and its @c operator() called with argument @c x
  765. * returns @c f(x). The functor @c pointer_to_binary_function does the same
  766. * thing, but with a double-argument @c f and @c operator().
  767. *
  768. * The function @c ptr_fun takes a pointer-to-function @c f and constructs
  769. * an instance of the appropriate functor.
  770. *
  771. * @{
  772. */
  773. /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  774. template<typename _Arg, typename _Result>
  775. class pointer_to_unary_function : public unary_function<_Arg, _Result>
  776. {
  777. protected:
  778. _Result (*_M_ptr)(_Arg);
  779.  
  780. public:
  781. pointer_to_unary_function() { }
  782.  
  783. explicit
  784. pointer_to_unary_function(_Result (*__x)(_Arg))
  785. : _M_ptr(__x) { }
  786.  
  787. _Result
  788. operator()(_Arg __x) const
  789. { return _M_ptr(__x); }
  790. };
  791.  
  792. /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  793. template<typename _Arg, typename _Result>
  794. inline pointer_to_unary_function<_Arg, _Result>
  795. ptr_fun(_Result (*__x)(_Arg))
  796. { return pointer_to_unary_function<_Arg, _Result>(__x); }
  797.  
  798. /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  799. template<typename _Arg1, typename _Arg2, typename _Result>
  800. class pointer_to_binary_function
  801. : public binary_function<_Arg1, _Arg2, _Result>
  802. {
  803. protected:
  804. _Result (*_M_ptr)(_Arg1, _Arg2);
  805.  
  806. public:
  807. pointer_to_binary_function() { }
  808.  
  809. explicit
  810. pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
  811. : _M_ptr(__x) { }
  812.  
  813. _Result
  814. operator()(_Arg1 __x, _Arg2 __y) const
  815. { return _M_ptr(__x, __y); }
  816. };
  817.  
  818. /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  819. template<typename _Arg1, typename _Arg2, typename _Result>
  820. inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
  821. ptr_fun(_Result (*__x)(_Arg1, _Arg2))
  822. { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
  823. /** @} */
  824.  
  825. template<typename _Tp>
  826. struct _Identity
  827. : public unary_function<_Tp,_Tp>
  828. {
  829. _Tp&
  830. operator()(_Tp& __x) const
  831. { return __x; }
  832.  
  833. const _Tp&
  834. operator()(const _Tp& __x) const
  835. { return __x; }
  836. };
  837.  
  838. template<typename _Pair>
  839. struct _Select1st
  840. : public unary_function<_Pair, typename _Pair::first_type>
  841. {
  842. typename _Pair::first_type&
  843. operator()(_Pair& __x) const
  844. { return __x.first; }
  845.  
  846. const typename _Pair::first_type&
  847. operator()(const _Pair& __x) const
  848. { return __x.first; }
  849.  
  850. #if __cplusplus >= 201103L
  851. template<typename _Pair2>
  852. typename _Pair2::first_type&
  853. operator()(_Pair2& __x) const
  854. { return __x.first; }
  855.  
  856. template<typename _Pair2>
  857. const typename _Pair2::first_type&
  858. operator()(const _Pair2& __x) const
  859. { return __x.first; }
  860. #endif
  861. };
  862.  
  863. template<typename _Pair>
  864. struct _Select2nd
  865. : public unary_function<_Pair, typename _Pair::second_type>
  866. {
  867. typename _Pair::second_type&
  868. operator()(_Pair& __x) const
  869. { return __x.second; }
  870.  
  871. const typename _Pair::second_type&
  872. operator()(const _Pair& __x) const
  873. { return __x.second; }
  874. };
  875.  
  876. // 20.3.8 adaptors pointers members
  877. /** @defgroup memory_adaptors Adaptors for pointers to members
  878. * @ingroup functors
  879. *
  880. * There are a total of 8 = 2^3 function objects in this family.
  881. * (1) Member functions taking no arguments vs member functions taking
  882. * one argument.
  883. * (2) Call through pointer vs call through reference.
  884. * (3) Const vs non-const member function.
  885. *
  886. * All of this complexity is in the function objects themselves. You can
  887. * ignore it by using the helper function mem_fun and mem_fun_ref,
  888. * which create whichever type of adaptor is appropriate.
  889. *
  890. * @{
  891. */
  892. /// One of the @link memory_adaptors adaptors for member
  893. /// pointers@endlink.
  894. template<typename _Ret, typename _Tp>
  895. class mem_fun_t : public unary_function<_Tp*, _Ret>
  896. {
  897. public:
  898. explicit
  899. mem_fun_t(_Ret (_Tp::*__pf)())
  900. : _M_f(__pf) { }
  901.  
  902. _Ret
  903. operator()(_Tp* __p) const
  904. { return (__p->*_M_f)(); }
  905.  
  906. private:
  907. _Ret (_Tp::*_M_f)();
  908. };
  909.  
  910. /// One of the @link memory_adaptors adaptors for member
  911. /// pointers@endlink.
  912. template<typename _Ret, typename _Tp>
  913. class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
  914. {
  915. public:
  916. explicit
  917. const_mem_fun_t(_Ret (_Tp::*__pf)() const)
  918. : _M_f(__pf) { }
  919.  
  920. _Ret
  921. operator()(const _Tp* __p) const
  922. { return (__p->*_M_f)(); }
  923.  
  924. private:
  925. _Ret (_Tp::*_M_f)() const;
  926. };
  927.  
  928. /// One of the @link memory_adaptors adaptors for member
  929. /// pointers@endlink.
  930. template<typename _Ret, typename _Tp>
  931. class mem_fun_ref_t : public unary_function<_Tp, _Ret>
  932. {
  933. public:
  934. explicit
  935. mem_fun_ref_t(_Ret (_Tp::*__pf)())
  936. : _M_f(__pf) { }
  937.  
  938. _Ret
  939. operator()(_Tp& __r) const
  940. { return (__r.*_M_f)(); }
  941.  
  942. private:
  943. _Ret (_Tp::*_M_f)();
  944. };
  945.  
  946. /// One of the @link memory_adaptors adaptors for member
  947. /// pointers@endlink.
  948. template<typename _Ret, typename _Tp>
  949. class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
  950. {
  951. public:
  952. explicit
  953. const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
  954. : _M_f(__pf) { }
  955.  
  956. _Ret
  957. operator()(const _Tp& __r) const
  958. { return (__r.*_M_f)(); }
  959.  
  960. private:
  961. _Ret (_Tp::*_M_f)() const;
  962. };
  963.  
  964. /// One of the @link memory_adaptors adaptors for member
  965. /// pointers@endlink.
  966. template<typename _Ret, typename _Tp, typename _Arg>
  967. class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
  968. {
  969. public:
  970. explicit
  971. mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
  972. : _M_f(__pf) { }
  973.  
  974. _Ret
  975. operator()(_Tp* __p, _Arg __x) const
  976. { return (__p->*_M_f)(__x); }
  977.  
  978. private:
  979. _Ret (_Tp::*_M_f)(_Arg);
  980. };
  981.  
  982. /// One of the @link memory_adaptors adaptors for member
  983. /// pointers@endlink.
  984. template<typename _Ret, typename _Tp, typename _Arg>
  985. class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
  986. {
  987. public:
  988. explicit
  989. const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
  990. : _M_f(__pf) { }
  991.  
  992. _Ret
  993. operator()(const _Tp* __p, _Arg __x) const
  994. { return (__p->*_M_f)(__x); }
  995.  
  996. private:
  997. _Ret (_Tp::*_M_f)(_Arg) const;
  998. };
  999.  
  1000. /// One of the @link memory_adaptors adaptors for member
  1001. /// pointers@endlink.
  1002. template<typename _Ret, typename _Tp, typename _Arg>
  1003. class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
  1004. {
  1005. public:
  1006. explicit
  1007. mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
  1008. : _M_f(__pf) { }
  1009.  
  1010. _Ret
  1011. operator()(_Tp& __r, _Arg __x) const
  1012. { return (__r.*_M_f)(__x); }
  1013.  
  1014. private:
  1015. _Ret (_Tp::*_M_f)(_Arg);
  1016. };
  1017.  
  1018. /// One of the @link memory_adaptors adaptors for member
  1019. /// pointers@endlink.
  1020. template<typename _Ret, typename _Tp, typename _Arg>
  1021. class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
  1022. {
  1023. public:
  1024. explicit
  1025. const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
  1026. : _M_f(__pf) { }
  1027.  
  1028. _Ret
  1029. operator()(const _Tp& __r, _Arg __x) const
  1030. { return (__r.*_M_f)(__x); }
  1031.  
  1032. private:
  1033. _Ret (_Tp::*_M_f)(_Arg) const;
  1034. };
  1035.  
  1036. // Mem_fun adaptor helper functions. There are only two:
  1037. // mem_fun and mem_fun_ref.
  1038. template<typename _Ret, typename _Tp>
  1039. inline mem_fun_t<_Ret, _Tp>
  1040. mem_fun(_Ret (_Tp::*__f)())
  1041. { return mem_fun_t<_Ret, _Tp>(__f); }
  1042.  
  1043. template<typename _Ret, typename _Tp>
  1044. inline const_mem_fun_t<_Ret, _Tp>
  1045. mem_fun(_Ret (_Tp::*__f)() const)
  1046. { return const_mem_fun_t<_Ret, _Tp>(__f); }
  1047.  
  1048. template<typename _Ret, typename _Tp>
  1049. inline mem_fun_ref_t<_Ret, _Tp>
  1050. mem_fun_ref(_Ret (_Tp::*__f)())
  1051. { return mem_fun_ref_t<_Ret, _Tp>(__f); }
  1052.  
  1053. template<typename _Ret, typename _Tp>
  1054. inline const_mem_fun_ref_t<_Ret, _Tp>
  1055. mem_fun_ref(_Ret (_Tp::*__f)() const)
  1056. { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
  1057.  
  1058. template<typename _Ret, typename _Tp, typename _Arg>
  1059. inline mem_fun1_t<_Ret, _Tp, _Arg>
  1060. mem_fun(_Ret (_Tp::*__f)(_Arg))
  1061. { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
  1062.  
  1063. template<typename _Ret, typename _Tp, typename _Arg>
  1064. inline const_mem_fun1_t<_Ret, _Tp, _Arg>
  1065. mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  1066. { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
  1067.  
  1068. template<typename _Ret, typename _Tp, typename _Arg>
  1069. inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
  1070. mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  1071. { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
  1072.  
  1073. template<typename _Ret, typename _Tp, typename _Arg>
  1074. inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
  1075. mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  1076. { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
  1077.  
  1078. /** @} */
  1079.  
  1080. _GLIBCXX_END_NAMESPACE_VERSION
  1081. } // namespace
  1082.  
  1083. #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
  1084. # include <backward/binders.h>
  1085. #endif
  1086.  
  1087. #endif /* _STL_FUNCTION_H */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!