1 | // Functor implementations -*- C++ -*- |
---|---|

2 | |

3 | // Copyright (C) 2001-2021 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 _functors_, are objects with an `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 _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 `a` and `b` containing `double`, |

84 | * and put the result in `a`, use |

85 | * \code |

86 | * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); |

87 | * \endcode |

88 | * To negate every element in `a`, use |

89 | * \code |

90 | * transform(a.begin(), a.end(), a.begin(), negate<double>()); |

91 | * \endcode |

92 | * The addition and negation functions will usually be inlined directly. |

93 | * |

94 | * An _adaptable function object_ is one which provides nested typedefs |

95 | * `result_type` and either `argument_type` (for a unary function) or |

96 | * `first_argument_type` and `second_argument_type` (for a binary function). |

97 | * Those typedefs are used by function object adaptors such as `bind2nd`. |

98 | * The standard library provides two class templates, `unary_function` and |

99 | * `binary_function`, which define those typedefs and so can be used as |

100 | * base classes of adaptable function objects. |

101 | * |

102 | * Since C++11 the use of function object adaptors has been superseded by |

103 | * more powerful tools such as lambda expressions, `function<>`, and more |

104 | * powerful type deduction (using `auto` and `decltype`). The helpers for |

105 | * defining adaptable function objects are deprecated since C++11, and no |

106 | * longer part of the standard library since C++17. However, they are still |

107 | * defined and used by libstdc++ after C++17, as a conforming extension. |

108 | * |

109 | * @{ |

110 | */ |

111 | |

112 | /** |

113 | * Helper for defining adaptable unary function objects. |

114 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |

115 | */ |

116 | template<typename _Arg, typename _Result> |

117 | struct unary_function |

118 | { |

119 | /// @c argument_type is the type of the argument |

120 | typedef _Arg argument_type; |

121 | |

122 | /// @c result_type is the return type |

123 | typedef _Result result_type; |

124 | }; |

125 | |

126 | /** |

127 | * Helper for defining adaptable binary function objects. |

128 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |

129 | */ |

130 | template<typename _Arg1, typename _Arg2, typename _Result> |

131 | struct binary_function |

132 | { |

133 | /// @c first_argument_type is the type of the first argument |

134 | typedef _Arg1 first_argument_type; |

135 | |

136 | /// @c second_argument_type is the type of the second argument |

137 | typedef _Arg2 second_argument_type; |

138 | |

139 | /// @c result_type is the return type |

140 | typedef _Result result_type; |

141 | }; |

142 | /** @} */ |

143 | |

144 | // 20.3.2 arithmetic |

145 | |

146 | /** @defgroup arithmetic_functors Arithmetic Function Object Classes |

147 | * @ingroup functors |

148 | * |

149 | * The library provides function objects for basic arithmetic operations. |

150 | * See the documentation for @link functors function objects @endlink |

151 | * for examples of their use. |

152 | * |

153 | * @{ |

154 | */ |

155 | |

156 | #if __cplusplus > 201103L |

157 | struct __is_transparent; // undefined |

158 | |

159 | template<typename _Tp = void> |

160 | struct plus; |

161 | |

162 | template<typename _Tp = void> |

163 | struct minus; |

164 | |

165 | template<typename _Tp = void> |

166 | struct multiplies; |

167 | |

168 | template<typename _Tp = void> |

169 | struct divides; |

170 | |

171 | template<typename _Tp = void> |

172 | struct modulus; |

173 | |

174 | template<typename _Tp = void> |

175 | struct negate; |

176 | #endif |

177 | |

178 | /// One of the @link arithmetic_functors math functors@endlink. |

179 | template<typename _Tp> |

180 | struct plus : public binary_function<_Tp, _Tp, _Tp> |

181 | { |

182 | /// Returns the sum |

183 | _GLIBCXX14_CONSTEXPR |

184 | _Tp |

185 | operator()(const _Tp& __x, const _Tp& __y) const |

186 | { return __x + __y; } |

187 | }; |

188 | |

189 | /// One of the @link arithmetic_functors math functors@endlink. |

190 | template<typename _Tp> |

191 | struct minus : public binary_function<_Tp, _Tp, _Tp> |

192 | { |

193 | _GLIBCXX14_CONSTEXPR |

194 | _Tp |

195 | operator()(const _Tp& __x, const _Tp& __y) const |

196 | { return __x - __y; } |

197 | }; |

198 | |

199 | /// One of the @link arithmetic_functors math functors@endlink. |

200 | template<typename _Tp> |

201 | struct multiplies : public binary_function<_Tp, _Tp, _Tp> |

202 | { |

203 | _GLIBCXX14_CONSTEXPR |

204 | _Tp |

205 | operator()(const _Tp& __x, const _Tp& __y) const |

206 | { return __x * __y; } |

207 | }; |

208 | |

209 | /// One of the @link arithmetic_functors math functors@endlink. |

210 | template<typename _Tp> |

211 | struct divides : public binary_function<_Tp, _Tp, _Tp> |

212 | { |

213 | _GLIBCXX14_CONSTEXPR |

214 | _Tp |

215 | operator()(const _Tp& __x, const _Tp& __y) const |

216 | { return __x / __y; } |

217 | }; |

218 | |

219 | /// One of the @link arithmetic_functors math functors@endlink. |

220 | template<typename _Tp> |

221 | struct modulus : public binary_function<_Tp, _Tp, _Tp> |

222 | { |

223 | _GLIBCXX14_CONSTEXPR |

224 | _Tp |

225 | operator()(const _Tp& __x, const _Tp& __y) const |

226 | { return __x % __y; } |

227 | }; |

228 | |

229 | /// One of the @link arithmetic_functors math functors@endlink. |

230 | template<typename _Tp> |

231 | struct negate : public unary_function<_Tp, _Tp> |

232 | { |

233 | _GLIBCXX14_CONSTEXPR |

234 | _Tp |

235 | operator()(const _Tp& __x) const |

236 | { return -__x; } |

237 | }; |

238 | |

239 | #if __cplusplus > 201103L |

240 | |

241 | #define __cpp_lib_transparent_operators 201510 |

242 | |

243 | template<> |

244 | struct plus<void> |

245 | { |

246 | template <typename _Tp, typename _Up> |

247 | _GLIBCXX14_CONSTEXPR |

248 | auto |

249 | operator()(_Tp&& __t, _Up&& __u) const |

250 | noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) |

251 | -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) |

252 | { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } |

253 | |

254 | typedef __is_transparent is_transparent; |

255 | }; |

256 | |

257 | /// One of the @link arithmetic_functors math functors@endlink. |

258 | template<> |

259 | struct minus<void> |

260 | { |

261 | template <typename _Tp, typename _Up> |

262 | _GLIBCXX14_CONSTEXPR |

263 | auto |

264 | operator()(_Tp&& __t, _Up&& __u) const |

265 | noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) |

266 | -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) |

267 | { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } |

268 | |

269 | typedef __is_transparent is_transparent; |

270 | }; |

271 | |

272 | /// One of the @link arithmetic_functors math functors@endlink. |

273 | template<> |

274 | struct multiplies<void> |

275 | { |

276 | template <typename _Tp, typename _Up> |

277 | _GLIBCXX14_CONSTEXPR |

278 | auto |

279 | operator()(_Tp&& __t, _Up&& __u) const |

280 | noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) |

281 | -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) |

282 | { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } |

283 | |

284 | typedef __is_transparent is_transparent; |

285 | }; |

286 | |

287 | /// One of the @link arithmetic_functors math functors@endlink. |

288 | template<> |

289 | struct divides<void> |

290 | { |

291 | template <typename _Tp, typename _Up> |

292 | _GLIBCXX14_CONSTEXPR |

293 | auto |

294 | operator()(_Tp&& __t, _Up&& __u) const |

295 | noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) |

296 | -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) |

297 | { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } |

298 | |

299 | typedef __is_transparent is_transparent; |

300 | }; |

301 | |

302 | /// One of the @link arithmetic_functors math functors@endlink. |

303 | template<> |

304 | struct modulus<void> |

305 | { |

306 | template <typename _Tp, typename _Up> |

307 | _GLIBCXX14_CONSTEXPR |

308 | auto |

309 | operator()(_Tp&& __t, _Up&& __u) const |

310 | noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) |

311 | -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) |

312 | { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } |

313 | |

314 | typedef __is_transparent is_transparent; |

315 | }; |

316 | |

317 | /// One of the @link arithmetic_functors math functors@endlink. |

318 | template<> |

319 | struct negate<void> |

320 | { |

321 | template <typename _Tp> |

322 | _GLIBCXX14_CONSTEXPR |

323 | auto |

324 | operator()(_Tp&& __t) const |

325 | noexcept(noexcept(-std::forward<_Tp>(__t))) |

326 | -> decltype(-std::forward<_Tp>(__t)) |

327 | { return -std::forward<_Tp>(__t); } |

328 | |

329 | typedef __is_transparent is_transparent; |

330 | }; |

331 | #endif |

332 | /** @} */ |

333 | |

334 | // 20.3.3 comparisons |

335 | /** @defgroup comparison_functors Comparison Classes |

336 | * @ingroup functors |

337 | * |

338 | * The library provides six wrapper functors for all the basic comparisons |

339 | * in C++, like @c <. |

340 | * |

341 | * @{ |

342 | */ |

343 | #if __cplusplus > 201103L |

344 | template<typename _Tp = void> |

345 | struct equal_to; |

346 | |

347 | template<typename _Tp = void> |

348 | struct not_equal_to; |

349 | |

350 | template<typename _Tp = void> |

351 | struct greater; |

352 | |

353 | template<typename _Tp = void> |

354 | struct less; |

355 | |

356 | template<typename _Tp = void> |

357 | struct greater_equal; |

358 | |

359 | template<typename _Tp = void> |

360 | struct less_equal; |

361 | #endif |

362 | |

363 | /// One of the @link comparison_functors comparison functors@endlink. |

364 | template<typename _Tp> |

365 | struct equal_to : public binary_function<_Tp, _Tp, bool> |

366 | { |

367 | _GLIBCXX14_CONSTEXPR |

368 | bool |

369 | operator()(const _Tp& __x, const _Tp& __y) const |

370 | { return __x == __y; } |

371 | }; |

372 | |

373 | /// One of the @link comparison_functors comparison functors@endlink. |

374 | template<typename _Tp> |

375 | struct not_equal_to : public binary_function<_Tp, _Tp, bool> |

376 | { |

377 | _GLIBCXX14_CONSTEXPR |

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 greater : public binary_function<_Tp, _Tp, bool> |

386 | { |

387 | _GLIBCXX14_CONSTEXPR |

388 | bool |

389 | operator()(const _Tp& __x, const _Tp& __y) const |

390 | { return __x > __y; } |

391 | }; |

392 | |

393 | /// One of the @link comparison_functors comparison functors@endlink. |

394 | template<typename _Tp> |

395 | struct less : public binary_function<_Tp, _Tp, bool> |

396 | { |

397 | _GLIBCXX14_CONSTEXPR |

398 | bool |

399 | operator()(const _Tp& __x, const _Tp& __y) const |

400 | { return __x < __y; } |

401 | }; |

402 | |

403 | /// One of the @link comparison_functors comparison functors@endlink. |

404 | template<typename _Tp> |

405 | struct greater_equal : public binary_function<_Tp, _Tp, bool> |

406 | { |

407 | _GLIBCXX14_CONSTEXPR |

408 | bool |

409 | operator()(const _Tp& __x, const _Tp& __y) const |

410 | { return __x >= __y; } |

411 | }; |

412 | |

413 | /// One of the @link comparison_functors comparison functors@endlink. |

414 | template<typename _Tp> |

415 | struct less_equal : public binary_function<_Tp, _Tp, bool> |

416 | { |

417 | _GLIBCXX14_CONSTEXPR |

418 | bool |

419 | operator()(const _Tp& __x, const _Tp& __y) const |

420 | { return __x <= __y; } |

421 | }; |

422 | |

423 | // Partial specialization of std::greater for pointers. |

424 | template<typename _Tp> |

425 | struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |

426 | { |

427 | _GLIBCXX14_CONSTEXPR bool |

428 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |

429 | { |

430 | #if __cplusplus >= 201402L |

431 | #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED |

432 | if (__builtin_is_constant_evaluated()) |

433 | #else |

434 | if (__builtin_constant_p(__x > __y)) |

435 | #endif |

436 | return __x > __y; |

437 | #endif |

438 | return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y; |

439 | } |

440 | }; |

441 | |

442 | // Partial specialization of std::less for pointers. |

443 | template<typename _Tp> |

444 | struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |

445 | { |

446 | _GLIBCXX14_CONSTEXPR bool |

447 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |

448 | { |

449 | #if __cplusplus >= 201402L |

450 | #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED |

451 | if (__builtin_is_constant_evaluated()) |

452 | #else |

453 | if (__builtin_constant_p(__x < __y)) |

454 | #endif |

455 | return __x < __y; |

456 | #endif |

457 | return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y; |

458 | } |

459 | }; |

460 | |

461 | // Partial specialization of std::greater_equal for pointers. |

462 | template<typename _Tp> |

463 | struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |

464 | { |

465 | _GLIBCXX14_CONSTEXPR bool |

466 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |

467 | { |

468 | #if __cplusplus >= 201402L |

469 | #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED |

470 | if (__builtin_is_constant_evaluated()) |

471 | #else |

472 | if (__builtin_constant_p(__x >= __y)) |

473 | #endif |

474 | return __x >= __y; |

475 | #endif |

476 | return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y; |

477 | } |

478 | }; |

479 | |

480 | // Partial specialization of std::less_equal for pointers. |

481 | template<typename _Tp> |

482 | struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> |

483 | { |

484 | _GLIBCXX14_CONSTEXPR bool |

485 | operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW |

486 | { |

487 | #if __cplusplus >= 201402L |

488 | #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED |

489 | if (__builtin_is_constant_evaluated()) |

490 | #else |

491 | if (__builtin_constant_p(__x <= __y)) |

492 | #endif |

493 | return __x <= __y; |

494 | #endif |

495 | return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y; |

496 | } |

497 | }; |

498 | |

499 | #if __cplusplus >= 201402L |

500 | /// One of the @link comparison_functors comparison functors@endlink. |

501 | template<> |

502 | struct equal_to<void> |

503 | { |

504 | template <typename _Tp, typename _Up> |

505 | constexpr auto |

506 | operator()(_Tp&& __t, _Up&& __u) const |

507 | noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) |

508 | -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) |

509 | { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } |

510 | |

511 | typedef __is_transparent is_transparent; |

512 | }; |

513 | |

514 | /// One of the @link comparison_functors comparison functors@endlink. |

515 | template<> |

516 | struct not_equal_to<void> |

517 | { |

518 | template <typename _Tp, typename _Up> |

519 | constexpr auto |

520 | operator()(_Tp&& __t, _Up&& __u) const |

521 | noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) |

522 | -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) |

523 | { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } |

524 | |

525 | typedef __is_transparent is_transparent; |

526 | }; |

527 | |

528 | /// One of the @link comparison_functors comparison functors@endlink. |

529 | template<> |

530 | struct greater<void> |

531 | { |

532 | template <typename _Tp, typename _Up> |

533 | constexpr auto |

534 | operator()(_Tp&& __t, _Up&& __u) const |

535 | noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) |

536 | -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) |

537 | { |

538 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |

539 | __ptr_cmp<_Tp, _Up>{}); |

540 | } |

541 | |

542 | template<typename _Tp, typename _Up> |

543 | constexpr bool |

544 | operator()(_Tp* __t, _Up* __u) const noexcept |

545 | { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |

546 | |

547 | typedef __is_transparent is_transparent; |

548 | |

549 | private: |

550 | template <typename _Tp, typename _Up> |

551 | static constexpr decltype(auto) |

552 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |

553 | { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } |

554 | |

555 | template <typename _Tp, typename _Up> |

556 | static constexpr bool |

557 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |

558 | { |

559 | return greater<const volatile void*>{}( |

560 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |

561 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |

562 | } |

563 | |

564 | // True if there is no viable operator> member function. |

565 | template<typename _Tp, typename _Up, typename = void> |

566 | struct __not_overloaded2 : true_type { }; |

567 | |

568 | // False if we can call T.operator>(U) |

569 | template<typename _Tp, typename _Up> |

570 | struct __not_overloaded2<_Tp, _Up, __void_t< |

571 | decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> |

572 | : false_type { }; |

573 | |

574 | // True if there is no overloaded operator> for these operands. |

575 | template<typename _Tp, typename _Up, typename = void> |

576 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |

577 | |

578 | // False if we can call operator>(T,U) |

579 | template<typename _Tp, typename _Up> |

580 | struct __not_overloaded<_Tp, _Up, __void_t< |

581 | decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> |

582 | : false_type { }; |

583 | |

584 | template<typename _Tp, typename _Up> |

585 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |

586 | is_convertible<_Tp, const volatile void*>, |

587 | is_convertible<_Up, const volatile void*>>; |

588 | }; |

589 | |

590 | /// One of the @link comparison_functors comparison functors@endlink. |

591 | template<> |

592 | struct less<void> |

593 | { |

594 | template <typename _Tp, typename _Up> |

595 | constexpr auto |

596 | operator()(_Tp&& __t, _Up&& __u) const |

597 | noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) |

598 | -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) |

599 | { |

600 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |

601 | __ptr_cmp<_Tp, _Up>{}); |

602 | } |

603 | |

604 | template<typename _Tp, typename _Up> |

605 | constexpr bool |

606 | operator()(_Tp* __t, _Up* __u) const noexcept |

607 | { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |

608 | |

609 | typedef __is_transparent is_transparent; |

610 | |

611 | private: |

612 | template <typename _Tp, typename _Up> |

613 | static constexpr decltype(auto) |

614 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |

615 | { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } |

616 | |

617 | template <typename _Tp, typename _Up> |

618 | static constexpr bool |

619 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |

620 | { |

621 | return less<const volatile void*>{}( |

622 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |

623 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |

624 | } |

625 | |

626 | // True if there is no viable operator< member function. |

627 | template<typename _Tp, typename _Up, typename = void> |

628 | struct __not_overloaded2 : true_type { }; |

629 | |

630 | // False if we can call T.operator<(U) |

631 | template<typename _Tp, typename _Up> |

632 | struct __not_overloaded2<_Tp, _Up, __void_t< |

633 | decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> |

634 | : false_type { }; |

635 | |

636 | // True if there is no overloaded operator< for these operands. |

637 | template<typename _Tp, typename _Up, typename = void> |

638 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |

639 | |

640 | // False if we can call operator<(T,U) |

641 | template<typename _Tp, typename _Up> |

642 | struct __not_overloaded<_Tp, _Up, __void_t< |

643 | decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> |

644 | : false_type { }; |

645 | |

646 | template<typename _Tp, typename _Up> |

647 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |

648 | is_convertible<_Tp, const volatile void*>, |

649 | is_convertible<_Up, const volatile void*>>; |

650 | }; |

651 | |

652 | /// One of the @link comparison_functors comparison functors@endlink. |

653 | template<> |

654 | struct greater_equal<void> |

655 | { |

656 | template <typename _Tp, typename _Up> |

657 | constexpr auto |

658 | operator()(_Tp&& __t, _Up&& __u) const |

659 | noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) |

660 | -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) |

661 | { |

662 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |

663 | __ptr_cmp<_Tp, _Up>{}); |

664 | } |

665 | |

666 | template<typename _Tp, typename _Up> |

667 | constexpr bool |

668 | operator()(_Tp* __t, _Up* __u) const noexcept |

669 | { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |

670 | |

671 | typedef __is_transparent is_transparent; |

672 | |

673 | private: |

674 | template <typename _Tp, typename _Up> |

675 | static constexpr decltype(auto) |

676 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |

677 | { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } |

678 | |

679 | template <typename _Tp, typename _Up> |

680 | static constexpr bool |

681 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |

682 | { |

683 | return greater_equal<const volatile void*>{}( |

684 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |

685 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |

686 | } |

687 | |

688 | // True if there is no viable operator>= member function. |

689 | template<typename _Tp, typename _Up, typename = void> |

690 | struct __not_overloaded2 : true_type { }; |

691 | |

692 | // False if we can call T.operator>=(U) |

693 | template<typename _Tp, typename _Up> |

694 | struct __not_overloaded2<_Tp, _Up, __void_t< |

695 | decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> |

696 | : false_type { }; |

697 | |

698 | // True if there is no overloaded operator>= for these operands. |

699 | template<typename _Tp, typename _Up, typename = void> |

700 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |

701 | |

702 | // False if we can call operator>=(T,U) |

703 | template<typename _Tp, typename _Up> |

704 | struct __not_overloaded<_Tp, _Up, __void_t< |

705 | decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> |

706 | : false_type { }; |

707 | |

708 | template<typename _Tp, typename _Up> |

709 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |

710 | is_convertible<_Tp, const volatile void*>, |

711 | is_convertible<_Up, const volatile void*>>; |

712 | }; |

713 | |

714 | /// One of the @link comparison_functors comparison functors@endlink. |

715 | template<> |

716 | struct less_equal<void> |

717 | { |

718 | template <typename _Tp, typename _Up> |

719 | constexpr auto |

720 | operator()(_Tp&& __t, _Up&& __u) const |

721 | noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) |

722 | -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) |

723 | { |

724 | return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), |

725 | __ptr_cmp<_Tp, _Up>{}); |

726 | } |

727 | |

728 | template<typename _Tp, typename _Up> |

729 | constexpr bool |

730 | operator()(_Tp* __t, _Up* __u) const noexcept |

731 | { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } |

732 | |

733 | typedef __is_transparent is_transparent; |

734 | |

735 | private: |

736 | template <typename _Tp, typename _Up> |

737 | static constexpr decltype(auto) |

738 | _S_cmp(_Tp&& __t, _Up&& __u, false_type) |

739 | { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } |

740 | |

741 | template <typename _Tp, typename _Up> |

742 | static constexpr bool |

743 | _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept |

744 | { |

745 | return less_equal<const volatile void*>{}( |

746 | static_cast<const volatile void*>(std::forward<_Tp>(__t)), |

747 | static_cast<const volatile void*>(std::forward<_Up>(__u))); |

748 | } |

749 | |

750 | // True if there is no viable operator<= member function. |

751 | template<typename _Tp, typename _Up, typename = void> |

752 | struct __not_overloaded2 : true_type { }; |

753 | |

754 | // False if we can call T.operator<=(U) |

755 | template<typename _Tp, typename _Up> |

756 | struct __not_overloaded2<_Tp, _Up, __void_t< |

757 | decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> |

758 | : false_type { }; |

759 | |

760 | // True if there is no overloaded operator<= for these operands. |

761 | template<typename _Tp, typename _Up, typename = void> |

762 | struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; |

763 | |

764 | // False if we can call operator<=(T,U) |

765 | template<typename _Tp, typename _Up> |

766 | struct __not_overloaded<_Tp, _Up, __void_t< |

767 | decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> |

768 | : false_type { }; |

769 | |

770 | template<typename _Tp, typename _Up> |

771 | using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, |

772 | is_convertible<_Tp, const volatile void*>, |

773 | is_convertible<_Up, const volatile void*>>; |

774 | }; |

775 | #endif // C++14 |

776 | /** @} */ |

777 | |

778 | // 20.3.4 logical operations |

779 | /** @defgroup logical_functors Boolean Operations Classes |

780 | * @ingroup functors |

781 | * |

782 | * The library provides function objects for the logical operations: |

783 | * `&&`, `||`, and `!`. |

784 | * |

785 | * @{ |

786 | */ |

787 | #if __cplusplus > 201103L |

788 | template<typename _Tp = void> |

789 | struct logical_and; |

790 | |

791 | template<typename _Tp = void> |

792 | struct logical_or; |

793 | |

794 | template<typename _Tp = void> |

795 | struct logical_not; |

796 | #endif |

797 | |

798 | /// One of the @link logical_functors Boolean operations functors@endlink. |

799 | template<typename _Tp> |

800 | struct logical_and : public binary_function<_Tp, _Tp, bool> |

801 | { |

802 | _GLIBCXX14_CONSTEXPR |

803 | bool |

804 | operator()(const _Tp& __x, const _Tp& __y) const |

805 | { return __x && __y; } |

806 | }; |

807 | |

808 | /// One of the @link logical_functors Boolean operations functors@endlink. |

809 | template<typename _Tp> |

810 | struct logical_or : public binary_function<_Tp, _Tp, bool> |

811 | { |

812 | _GLIBCXX14_CONSTEXPR |

813 | bool |

814 | operator()(const _Tp& __x, const _Tp& __y) const |

815 | { return __x || __y; } |

816 | }; |

817 | |

818 | /// One of the @link logical_functors Boolean operations functors@endlink. |

819 | template<typename _Tp> |

820 | struct logical_not : public unary_function<_Tp, bool> |

821 | { |

822 | _GLIBCXX14_CONSTEXPR |

823 | bool |

824 | operator()(const _Tp& __x) const |

825 | { return !__x; } |

826 | }; |

827 | |

828 | #if __cplusplus > 201103L |

829 | /// One of the @link logical_functors Boolean operations functors@endlink. |

830 | template<> |

831 | struct logical_and<void> |

832 | { |

833 | template <typename _Tp, typename _Up> |

834 | _GLIBCXX14_CONSTEXPR |

835 | auto |

836 | operator()(_Tp&& __t, _Up&& __u) const |

837 | noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) |

838 | -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) |

839 | { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } |

840 | |

841 | typedef __is_transparent is_transparent; |

842 | }; |

843 | |

844 | /// One of the @link logical_functors Boolean operations functors@endlink. |

845 | template<> |

846 | struct logical_or<void> |

847 | { |

848 | template <typename _Tp, typename _Up> |

849 | _GLIBCXX14_CONSTEXPR |

850 | auto |

851 | operator()(_Tp&& __t, _Up&& __u) const |

852 | noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) |

853 | -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) |

854 | { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } |

855 | |

856 | typedef __is_transparent is_transparent; |

857 | }; |

858 | |

859 | /// One of the @link logical_functors Boolean operations functors@endlink. |

860 | template<> |

861 | struct logical_not<void> |

862 | { |

863 | template <typename _Tp> |

864 | _GLIBCXX14_CONSTEXPR |

865 | auto |

866 | operator()(_Tp&& __t) const |

867 | noexcept(noexcept(!std::forward<_Tp>(__t))) |

868 | -> decltype(!std::forward<_Tp>(__t)) |

869 | { return !std::forward<_Tp>(__t); } |

870 | |

871 | typedef __is_transparent is_transparent; |

872 | }; |

873 | #endif |

874 | /** @} */ |

875 | |

876 | #if __cplusplus > 201103L |

877 | template<typename _Tp = void> |

878 | struct bit_and; |

879 | |

880 | template<typename _Tp = void> |

881 | struct bit_or; |

882 | |

883 | template<typename _Tp = void> |

884 | struct bit_xor; |

885 | |

886 | template<typename _Tp = void> |

887 | struct bit_not; |

888 | #endif |

889 | |

890 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |

891 | // DR 660. Missing Bitwise Operations. |

892 | template<typename _Tp> |

893 | struct bit_and : public binary_function<_Tp, _Tp, _Tp> |

894 | { |

895 | _GLIBCXX14_CONSTEXPR |

896 | _Tp |

897 | operator()(const _Tp& __x, const _Tp& __y) const |

898 | { return __x & __y; } |

899 | }; |

900 | |

901 | template<typename _Tp> |

902 | struct bit_or : public binary_function<_Tp, _Tp, _Tp> |

903 | { |

904 | _GLIBCXX14_CONSTEXPR |

905 | _Tp |

906 | operator()(const _Tp& __x, const _Tp& __y) const |

907 | { return __x | __y; } |

908 | }; |

909 | |

910 | template<typename _Tp> |

911 | struct bit_xor : public binary_function<_Tp, _Tp, _Tp> |

912 | { |

913 | _GLIBCXX14_CONSTEXPR |

914 | _Tp |

915 | operator()(const _Tp& __x, const _Tp& __y) const |

916 | { return __x ^ __y; } |

917 | }; |

918 | |

919 | template<typename _Tp> |

920 | struct bit_not : public unary_function<_Tp, _Tp> |

921 | { |

922 | _GLIBCXX14_CONSTEXPR |

923 | _Tp |

924 | operator()(const _Tp& __x) const |

925 | { return ~__x; } |

926 | }; |

927 | |

928 | #if __cplusplus > 201103L |

929 | template <> |

930 | struct bit_and<void> |

931 | { |

932 | template <typename _Tp, typename _Up> |

933 | _GLIBCXX14_CONSTEXPR |

934 | auto |

935 | operator()(_Tp&& __t, _Up&& __u) const |

936 | noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) |

937 | -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) |

938 | { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } |

939 | |

940 | typedef __is_transparent is_transparent; |

941 | }; |

942 | |

943 | template <> |

944 | struct bit_or<void> |

945 | { |

946 | template <typename _Tp, typename _Up> |

947 | _GLIBCXX14_CONSTEXPR |

948 | auto |

949 | operator()(_Tp&& __t, _Up&& __u) const |

950 | noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) |

951 | -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) |

952 | { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } |

953 | |

954 | typedef __is_transparent is_transparent; |

955 | }; |

956 | |

957 | template <> |

958 | struct bit_xor<void> |

959 | { |

960 | template <typename _Tp, typename _Up> |

961 | _GLIBCXX14_CONSTEXPR |

962 | auto |

963 | operator()(_Tp&& __t, _Up&& __u) const |

964 | noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) |

965 | -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) |

966 | { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } |

967 | |

968 | typedef __is_transparent is_transparent; |

969 | }; |

970 | |

971 | template <> |

972 | struct bit_not<void> |

973 | { |

974 | template <typename _Tp> |

975 | _GLIBCXX14_CONSTEXPR |

976 | auto |

977 | operator()(_Tp&& __t) const |

978 | noexcept(noexcept(~std::forward<_Tp>(__t))) |

979 | -> decltype(~std::forward<_Tp>(__t)) |

980 | { return ~std::forward<_Tp>(__t); } |

981 | |

982 | typedef __is_transparent is_transparent; |

983 | }; |

984 | #endif |

985 | |

986 | // 20.3.5 negators |

987 | /** @defgroup negators Negators |

988 | * @ingroup functors |

989 | * |

990 | * The function templates `not1` and `not2` are function object adaptors, |

991 | * which each take a predicate functor and wrap it in an instance of |

992 | * `unary_negate` or `binary_negate`, respectively. Those classes are |

993 | * functors whose `operator()` evaluates the wrapped predicate function |

994 | * and then returns the negation of the result. |

995 | * |

996 | * For example, given a vector of integers and a trivial predicate, |

997 | * \code |

998 | * struct IntGreaterThanThree |

999 | * : public std::unary_function<int, bool> |

1000 | * { |

1001 | * bool operator() (int x) const { return x > 3; } |

1002 | * }; |

1003 | * |

1004 | * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); |

1005 | * \endcode |

1006 | * The call to `find_if` will locate the first index (i) of `v` for which |

1007 | * `!(v[i] > 3)` is true. |

1008 | * |

1009 | * The not1/unary_negate combination works on predicates taking a single |

1010 | * argument. The not2/binary_negate combination works on predicates taking |

1011 | * two arguments. |

1012 | * |

1013 | * @deprecated Deprecated in C++17, no longer in the standard since C++20. |

1014 | * Use `not_fn` instead. |

1015 | * |

1016 | * @{ |

1017 | */ |

1018 | /// One of the @link negators negation functors@endlink. |

1019 | template<typename _Predicate> |

1020 | class unary_negate |

1021 | : public unary_function<typename _Predicate::argument_type, bool> |

1022 | { |

1023 | protected: |

1024 | _Predicate _M_pred; |

1025 | |

1026 | public: |

1027 | _GLIBCXX14_CONSTEXPR |

1028 | explicit |

1029 | unary_negate(const _Predicate& __x) : _M_pred(__x) { } |

1030 | |

1031 | _GLIBCXX14_CONSTEXPR |

1032 | bool |

1033 | operator()(const typename _Predicate::argument_type& __x) const |

1034 | { return !_M_pred(__x); } |

1035 | }; |

1036 | |

1037 | /// One of the @link negators negation functors@endlink. |

1038 | template<typename _Predicate> |

1039 | _GLIBCXX14_CONSTEXPR |

1040 | inline unary_negate<_Predicate> |

1041 | not1(const _Predicate& __pred) |

1042 | { return unary_negate<_Predicate>(__pred); } |

1043 | |

1044 | /// One of the @link negators negation functors@endlink. |

1045 | template<typename _Predicate> |

1046 | class binary_negate |

1047 | : public binary_function<typename _Predicate::first_argument_type, |

1048 | typename _Predicate::second_argument_type, bool> |

1049 | { |

1050 | protected: |

1051 | _Predicate _M_pred; |

1052 | |

1053 | public: |

1054 | _GLIBCXX14_CONSTEXPR |

1055 | explicit |

1056 | binary_negate(const _Predicate& __x) : _M_pred(__x) { } |

1057 | |

1058 | _GLIBCXX14_CONSTEXPR |

1059 | bool |

1060 | operator()(const typename _Predicate::first_argument_type& __x, |

1061 | const typename _Predicate::second_argument_type& __y) const |

1062 | { return !_M_pred(__x, __y); } |

1063 | }; |

1064 | |

1065 | /// One of the @link negators negation functors@endlink. |

1066 | template<typename _Predicate> |

1067 | _GLIBCXX14_CONSTEXPR |

1068 | inline binary_negate<_Predicate> |

1069 | not2(const _Predicate& __pred) |

1070 | { return binary_negate<_Predicate>(__pred); } |

1071 | /** @} */ |

1072 | |

1073 | // 20.3.7 adaptors pointers functions |

1074 | /** @defgroup pointer_adaptors Adaptors for pointers to functions |

1075 | * @ingroup functors |

1076 | * |

1077 | * The advantage of function objects over pointers to functions is that |

1078 | * the objects in the standard library declare nested typedefs describing |

1079 | * their argument and result types with uniform names (e.g., `result_type` |

1080 | * from the base classes `unary_function` and `binary_function`). |

1081 | * Sometimes those typedefs are required, not just optional. |

1082 | * |

1083 | * Adaptors are provided to turn pointers to unary (single-argument) and |

1084 | * binary (double-argument) functions into function objects. The |

1085 | * long-winded functor `pointer_to_unary_function` is constructed with a |

1086 | * function pointer `f`, and its `operator()` called with argument `x` |

1087 | * returns `f(x)`. The functor `pointer_to_binary_function` does the same |

1088 | * thing, but with a double-argument `f` and `operator()`. |

1089 | * |

1090 | * The function `ptr_fun` takes a pointer-to-function `f` and constructs |

1091 | * an instance of the appropriate functor. |

1092 | * |

1093 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |

1094 | * |

1095 | * @{ |

1096 | */ |

1097 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |

1098 | template<typename _Arg, typename _Result> |

1099 | class pointer_to_unary_function : public unary_function<_Arg, _Result> |

1100 | { |

1101 | protected: |

1102 | _Result (*_M_ptr)(_Arg); |

1103 | |

1104 | public: |

1105 | pointer_to_unary_function() { } |

1106 | |

1107 | explicit |

1108 | pointer_to_unary_function(_Result (*__x)(_Arg)) |

1109 | : _M_ptr(__x) { } |

1110 | |

1111 | _Result |

1112 | operator()(_Arg __x) const |

1113 | { return _M_ptr(__x); } |

1114 | }; |

1115 | |

1116 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |

1117 | template<typename _Arg, typename _Result> |

1118 | inline pointer_to_unary_function<_Arg, _Result> |

1119 | ptr_fun(_Result (*__x)(_Arg)) |

1120 | { return pointer_to_unary_function<_Arg, _Result>(__x); } |

1121 | |

1122 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |

1123 | template<typename _Arg1, typename _Arg2, typename _Result> |

1124 | class pointer_to_binary_function |

1125 | : public binary_function<_Arg1, _Arg2, _Result> |

1126 | { |

1127 | protected: |

1128 | _Result (*_M_ptr)(_Arg1, _Arg2); |

1129 | |

1130 | public: |

1131 | pointer_to_binary_function() { } |

1132 | |

1133 | explicit |

1134 | pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) |

1135 | : _M_ptr(__x) { } |

1136 | |

1137 | _Result |

1138 | operator()(_Arg1 __x, _Arg2 __y) const |

1139 | { return _M_ptr(__x, __y); } |

1140 | }; |

1141 | |

1142 | /// One of the @link pointer_adaptors adaptors for function pointers@endlink. |

1143 | template<typename _Arg1, typename _Arg2, typename _Result> |

1144 | inline pointer_to_binary_function<_Arg1, _Arg2, _Result> |

1145 | ptr_fun(_Result (*__x)(_Arg1, _Arg2)) |

1146 | { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } |

1147 | /** @} */ |

1148 | |

1149 | template<typename _Tp> |

1150 | struct _Identity |

1151 | : public unary_function<_Tp, _Tp> |

1152 | { |

1153 | _Tp& |

1154 | operator()(_Tp& __x) const |

1155 | { return __x; } |

1156 | |

1157 | const _Tp& |

1158 | operator()(const _Tp& __x) const |

1159 | { return __x; } |

1160 | }; |

1161 | |

1162 | // Partial specialization, avoids confusing errors in e.g. std::set<const T>. |

1163 | template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { }; |

1164 | |

1165 | template<typename _Pair> |

1166 | struct _Select1st |

1167 | : public unary_function<_Pair, typename _Pair::first_type> |

1168 | { |

1169 | typename _Pair::first_type& |

1170 | operator()(_Pair& __x) const |

1171 | { return __x.first; } |

1172 | |

1173 | const typename _Pair::first_type& |

1174 | operator()(const _Pair& __x) const |

1175 | { return __x.first; } |

1176 | |

1177 | #if __cplusplus >= 201103L |

1178 | template<typename _Pair2> |

1179 | typename _Pair2::first_type& |

1180 | operator()(_Pair2& __x) const |

1181 | { return __x.first; } |

1182 | |

1183 | template<typename _Pair2> |

1184 | const typename _Pair2::first_type& |

1185 | operator()(const _Pair2& __x) const |

1186 | { return __x.first; } |

1187 | #endif |

1188 | }; |

1189 | |

1190 | template<typename _Pair> |

1191 | struct _Select2nd |

1192 | : public unary_function<_Pair, typename _Pair::second_type> |

1193 | { |

1194 | typename _Pair::second_type& |

1195 | operator()(_Pair& __x) const |

1196 | { return __x.second; } |

1197 | |

1198 | const typename _Pair::second_type& |

1199 | operator()(const _Pair& __x) const |

1200 | { return __x.second; } |

1201 | }; |

1202 | |

1203 | // 20.3.8 adaptors pointers members |

1204 | /** @defgroup ptrmem_adaptors Adaptors for pointers to members |

1205 | * @ingroup functors |

1206 | * |

1207 | * There are a total of 8 = 2^3 function objects in this family. |

1208 | * (1) Member functions taking no arguments vs member functions taking |

1209 | * one argument. |

1210 | * (2) Call through pointer vs call through reference. |

1211 | * (3) Const vs non-const member function. |

1212 | * |

1213 | * All of this complexity is in the function objects themselves. You can |

1214 | * ignore it by using the helper function `mem_fun` and `mem_fun_ref`, |

1215 | * which create whichever type of adaptor is appropriate. |

1216 | * |

1217 | * @deprecated Deprecated in C++11, no longer in the standard since C++17. |

1218 | * Use `mem_fn` instead. |

1219 | * |

1220 | * @{ |

1221 | */ |

1222 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1223 | template<typename _Ret, typename _Tp> |

1224 | class mem_fun_t : public unary_function<_Tp*, _Ret> |

1225 | { |

1226 | public: |

1227 | explicit |

1228 | mem_fun_t(_Ret (_Tp::*__pf)()) |

1229 | : _M_f(__pf) { } |

1230 | |

1231 | _Ret |

1232 | operator()(_Tp* __p) const |

1233 | { return (__p->*_M_f)(); } |

1234 | |

1235 | private: |

1236 | _Ret (_Tp::*_M_f)(); |

1237 | }; |

1238 | |

1239 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1240 | template<typename _Ret, typename _Tp> |

1241 | class const_mem_fun_t : public unary_function<const _Tp*, _Ret> |

1242 | { |

1243 | public: |

1244 | explicit |

1245 | const_mem_fun_t(_Ret (_Tp::*__pf)() const) |

1246 | : _M_f(__pf) { } |

1247 | |

1248 | _Ret |

1249 | operator()(const _Tp* __p) const |

1250 | { return (__p->*_M_f)(); } |

1251 | |

1252 | private: |

1253 | _Ret (_Tp::*_M_f)() const; |

1254 | }; |

1255 | |

1256 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1257 | template<typename _Ret, typename _Tp> |

1258 | class mem_fun_ref_t : public unary_function<_Tp, _Ret> |

1259 | { |

1260 | public: |

1261 | explicit |

1262 | mem_fun_ref_t(_Ret (_Tp::*__pf)()) |

1263 | : _M_f(__pf) { } |

1264 | |

1265 | _Ret |

1266 | operator()(_Tp& __r) const |

1267 | { return (__r.*_M_f)(); } |

1268 | |

1269 | private: |

1270 | _Ret (_Tp::*_M_f)(); |

1271 | }; |

1272 | |

1273 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1274 | template<typename _Ret, typename _Tp> |

1275 | class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> |

1276 | { |

1277 | public: |

1278 | explicit |

1279 | const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) |

1280 | : _M_f(__pf) { } |

1281 | |

1282 | _Ret |

1283 | operator()(const _Tp& __r) const |

1284 | { return (__r.*_M_f)(); } |

1285 | |

1286 | private: |

1287 | _Ret (_Tp::*_M_f)() const; |

1288 | }; |

1289 | |

1290 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1291 | template<typename _Ret, typename _Tp, typename _Arg> |

1292 | class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> |

1293 | { |

1294 | public: |

1295 | explicit |

1296 | mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) |

1297 | : _M_f(__pf) { } |

1298 | |

1299 | _Ret |

1300 | operator()(_Tp* __p, _Arg __x) const |

1301 | { return (__p->*_M_f)(__x); } |

1302 | |

1303 | private: |

1304 | _Ret (_Tp::*_M_f)(_Arg); |

1305 | }; |

1306 | |

1307 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1308 | template<typename _Ret, typename _Tp, typename _Arg> |

1309 | class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> |

1310 | { |

1311 | public: |

1312 | explicit |

1313 | const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) |

1314 | : _M_f(__pf) { } |

1315 | |

1316 | _Ret |

1317 | operator()(const _Tp* __p, _Arg __x) const |

1318 | { return (__p->*_M_f)(__x); } |

1319 | |

1320 | private: |

1321 | _Ret (_Tp::*_M_f)(_Arg) const; |

1322 | }; |

1323 | |

1324 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1325 | template<typename _Ret, typename _Tp, typename _Arg> |

1326 | class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |

1327 | { |

1328 | public: |

1329 | explicit |

1330 | mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) |

1331 | : _M_f(__pf) { } |

1332 | |

1333 | _Ret |

1334 | operator()(_Tp& __r, _Arg __x) const |

1335 | { return (__r.*_M_f)(__x); } |

1336 | |

1337 | private: |

1338 | _Ret (_Tp::*_M_f)(_Arg); |

1339 | }; |

1340 | |

1341 | /// One of the @link ptrmem_adaptors adaptors for member pointers@endlink. |

1342 | template<typename _Ret, typename _Tp, typename _Arg> |

1343 | class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> |

1344 | { |

1345 | public: |

1346 | explicit |

1347 | const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) |

1348 | : _M_f(__pf) { } |

1349 | |

1350 | _Ret |

1351 | operator()(const _Tp& __r, _Arg __x) const |

1352 | { return (__r.*_M_f)(__x); } |

1353 | |

1354 | private: |

1355 | _Ret (_Tp::*_M_f)(_Arg) const; |

1356 | }; |

1357 | |

1358 | // Mem_fun adaptor helper functions. There are only two: |

1359 | // mem_fun and mem_fun_ref. |

1360 | template<typename _Ret, typename _Tp> |

1361 | inline mem_fun_t<_Ret, _Tp> |

1362 | mem_fun(_Ret (_Tp::*__f)()) |

1363 | { return mem_fun_t<_Ret, _Tp>(__f); } |

1364 | |

1365 | template<typename _Ret, typename _Tp> |

1366 | inline const_mem_fun_t<_Ret, _Tp> |

1367 | mem_fun(_Ret (_Tp::*__f)() const) |

1368 | { return const_mem_fun_t<_Ret, _Tp>(__f); } |

1369 | |

1370 | template<typename _Ret, typename _Tp> |

1371 | inline mem_fun_ref_t<_Ret, _Tp> |

1372 | mem_fun_ref(_Ret (_Tp::*__f)()) |

1373 | { return mem_fun_ref_t<_Ret, _Tp>(__f); } |

1374 | |

1375 | template<typename _Ret, typename _Tp> |

1376 | inline const_mem_fun_ref_t<_Ret, _Tp> |

1377 | mem_fun_ref(_Ret (_Tp::*__f)() const) |

1378 | { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } |

1379 | |

1380 | template<typename _Ret, typename _Tp, typename _Arg> |

1381 | inline mem_fun1_t<_Ret, _Tp, _Arg> |

1382 | mem_fun(_Ret (_Tp::*__f)(_Arg)) |

1383 | { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |

1384 | |

1385 | template<typename _Ret, typename _Tp, typename _Arg> |

1386 | inline const_mem_fun1_t<_Ret, _Tp, _Arg> |

1387 | mem_fun(_Ret (_Tp::*__f)(_Arg) const) |

1388 | { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } |

1389 | |

1390 | template<typename _Ret, typename _Tp, typename _Arg> |

1391 | inline mem_fun1_ref_t<_Ret, _Tp, _Arg> |

1392 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) |

1393 | { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |

1394 | |

1395 | template<typename _Ret, typename _Tp, typename _Arg> |

1396 | inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> |

1397 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) |

1398 | { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } |

1399 | |

1400 | /** @} */ |

1401 | |

1402 | #if __cplusplus >= 201402L |

1403 | template<typename _Func, typename _SfinaeType, typename = __void_t<>> |

1404 | struct __has_is_transparent |

1405 | { }; |

1406 | |

1407 | template<typename _Func, typename _SfinaeType> |

1408 | struct __has_is_transparent<_Func, _SfinaeType, |

1409 | __void_t<typename _Func::is_transparent>> |

1410 | { typedef void type; }; |

1411 | |

1412 | template<typename _Func, typename _SfinaeType> |

1413 | using __has_is_transparent_t |

1414 | = typename __has_is_transparent<_Func, _SfinaeType>::type; |

1415 | #endif |

1416 | |

1417 | _GLIBCXX_END_NAMESPACE_VERSION |

1418 | } // namespace |

1419 | |

1420 | #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED |

1421 | # include <backward/binders.h> |

1422 | #endif |

1423 | |

1424 | #endif /* _STL_FUNCTION_H */ |

1425 |