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

2 | |

3 | // Copyright (C) 2001-2017 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 | _GLIBCXX14_CONSTEXPR |

170 | _Tp |

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

172 | { return __x + __y; } |

173 | }; |

174 | |

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

176 | template<typename _Tp> |

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

178 | { |

179 | _GLIBCXX14_CONSTEXPR |

180 | _Tp |

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

182 | { return __x - __y; } |

183 | }; |

184 | |

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

186 | template<typename _Tp> |

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

188 | { |

189 | _GLIBCXX14_CONSTEXPR |

190 | _Tp |

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

192 | { return __x * __y; } |

193 | }; |

194 | |

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

196 | template<typename _Tp> |

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

198 | { |

199 | _GLIBCXX14_CONSTEXPR |

200 | _Tp |

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

202 | { return __x / __y; } |

203 | }; |

204 | |

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

206 | template<typename _Tp> |

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

208 | { |

209 | _GLIBCXX14_CONSTEXPR |

210 | _Tp |

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

212 | { return __x % __y; } |

213 | }; |

214 | |

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

216 | template<typename _Tp> |

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

218 | { |

219 | _GLIBCXX14_CONSTEXPR |

220 | _Tp |

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

222 | { return -__x; } |

223 | }; |

224 | |

225 | #if __cplusplus > 201103L |

226 | |

227 | #define __cpp_lib_transparent_operators 201510 |

228 | |

229 | template<> |

230 | struct plus<void> |

231 | { |

232 | template <typename _Tp, typename _Up> |

233 | _GLIBCXX14_CONSTEXPR |

234 | auto |

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

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

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

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

239 | |

240 | typedef __is_transparent is_transparent; |

241 | }; |

242 | |

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

244 | template<> |

245 | struct minus<void> |

246 | { |

247 | template <typename _Tp, typename _Up> |

248 | _GLIBCXX14_CONSTEXPR |

249 | auto |

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

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

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

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

254 | |

255 | typedef __is_transparent is_transparent; |

256 | }; |

257 | |

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

259 | template<> |

260 | struct multiplies<void> |

261 | { |

262 | template <typename _Tp, typename _Up> |

263 | _GLIBCXX14_CONSTEXPR |

264 | auto |

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

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

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

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

269 | |

270 | typedef __is_transparent is_transparent; |

271 | }; |

272 | |

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

274 | template<> |

275 | struct divides<void> |

276 | { |

277 | template <typename _Tp, typename _Up> |

278 | _GLIBCXX14_CONSTEXPR |

279 | auto |

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

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

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

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

284 | |

285 | typedef __is_transparent is_transparent; |

286 | }; |

287 | |

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

289 | template<> |

290 | struct modulus<void> |

291 | { |

292 | template <typename _Tp, typename _Up> |

293 | _GLIBCXX14_CONSTEXPR |

294 | auto |

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

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

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

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

299 | |

300 | typedef __is_transparent is_transparent; |

301 | }; |

302 | |

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

304 | template<> |

305 | struct negate<void> |

306 | { |

307 | template <typename _Tp> |

308 | _GLIBCXX14_CONSTEXPR |

309 | auto |

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

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

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

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

314 | |

315 | typedef __is_transparent is_transparent; |

316 | }; |

317 | #endif |

318 | /** @} */ |

319 | |

320 | // 20.3.3 comparisons |

321 | /** @defgroup comparison_functors Comparison Classes |

322 | * @ingroup functors |

323 | * |

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

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

326 | * |

327 | * @{ |

328 | */ |

329 | #if __cplusplus > 201103L |

330 | template<typename _Tp = void> |

331 | struct equal_to; |

332 | |

333 | template<typename _Tp = void> |

334 | struct not_equal_to; |

335 | |

336 | template<typename _Tp = void> |

337 | struct greater; |

338 | |

339 | template<typename _Tp = void> |

340 | struct less; |

341 | |

342 | template<typename _Tp = void> |

343 | struct greater_equal; |

344 | |

345 | template<typename _Tp = void> |

346 | struct less_equal; |

347 | #endif |

348 | |

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

350 | template<typename _Tp> |

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

352 | { |

353 | _GLIBCXX14_CONSTEXPR |

354 | bool |

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

356 | { return __x == __y; } |

357 | }; |

358 | |

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

360 | template<typename _Tp> |

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

362 | { |

363 | _GLIBCXX14_CONSTEXPR |

364 | bool |

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

366 | { return __x != __y; } |

367 | }; |

368 | |

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

370 | template<typename _Tp> |

371 | struct greater : public binary_function<_Tp, _Tp, bool> |

372 | { |

373 | _GLIBCXX14_CONSTEXPR |

374 | bool |

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

376 | { return __x > __y; } |

377 | }; |

378 | |

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

380 | template<typename _Tp> |

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

382 | { |

383 | _GLIBCXX14_CONSTEXPR |

384 | bool |

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

386 | { return __x < __y; } |

387 | }; |

388 | |

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

390 | template<typename _Tp> |

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

392 | { |

393 | _GLIBCXX14_CONSTEXPR |

394 | bool |

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

396 | { return __x >= __y; } |

397 | }; |

398 | |

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

400 | template<typename _Tp> |

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

402 | { |

403 | _GLIBCXX14_CONSTEXPR |

404 | bool |

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

406 | { return __x <= __y; } |

407 | }; |

408 | |

409 | #if __cplusplus > 201103L |

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

411 | template<> |

412 | struct equal_to<void> |

413 | { |

414 | template <typename _Tp, typename _Up> |

415 | _GLIBCXX14_CONSTEXPR |

416 | auto |

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

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

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

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

421 | |

422 | typedef __is_transparent is_transparent; |

423 | }; |

424 | |

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

426 | template<> |

427 | struct not_equal_to<void> |

428 | { |

429 | template <typename _Tp, typename _Up> |

430 | _GLIBCXX14_CONSTEXPR |

431 | auto |

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

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

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

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

436 | |

437 | typedef __is_transparent is_transparent; |

438 | }; |

439 | |

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

441 | template<> |

442 | struct greater<void> |

443 | { |

444 | template <typename _Tp, typename _Up> |

445 | _GLIBCXX14_CONSTEXPR |

446 | auto |

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

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

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

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

451 | |

452 | typedef __is_transparent is_transparent; |

453 | }; |

454 | |

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

456 | template<> |

457 | struct less<void> |

458 | { |

459 | template <typename _Tp, typename _Up> |

460 | _GLIBCXX14_CONSTEXPR |

461 | auto |

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

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

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

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

466 | |

467 | typedef __is_transparent is_transparent; |

468 | }; |

469 | |

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

471 | template<> |

472 | struct greater_equal<void> |

473 | { |

474 | template <typename _Tp, typename _Up> |

475 | _GLIBCXX14_CONSTEXPR |

476 | auto |

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

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

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

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

481 | |

482 | typedef __is_transparent is_transparent; |

483 | }; |

484 | |

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

486 | template<> |

487 | struct less_equal<void> |

488 | { |

489 | template <typename _Tp, typename _Up> |

490 | _GLIBCXX14_CONSTEXPR |

491 | auto |

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

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

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

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

496 | |

497 | typedef __is_transparent is_transparent; |

498 | }; |

499 | #endif |

500 | /** @} */ |

501 | |

502 | // 20.3.4 logical operations |

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

504 | * @ingroup functors |

505 | * |

506 | * Here are wrapper functors for Boolean operations: @c &&, @c ||, |

507 | * and @c !. |

508 | * |

509 | * @{ |

510 | */ |

511 | #if __cplusplus > 201103L |

512 | template<typename _Tp = void> |

513 | struct logical_and; |

514 | |

515 | template<typename _Tp = void> |

516 | struct logical_or; |

517 | |

518 | template<typename _Tp = void> |

519 | struct logical_not; |

520 | #endif |

521 | |

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

523 | template<typename _Tp> |

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

525 | { |

526 | _GLIBCXX14_CONSTEXPR |

527 | bool |

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

529 | { return __x && __y; } |

530 | }; |

531 | |

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

533 | template<typename _Tp> |

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

535 | { |

536 | _GLIBCXX14_CONSTEXPR |

537 | bool |

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

539 | { return __x || __y; } |

540 | }; |

541 | |

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

543 | template<typename _Tp> |

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

545 | { |

546 | _GLIBCXX14_CONSTEXPR |

547 | bool |

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

549 | { return !__x; } |

550 | }; |

551 | |

552 | #if __cplusplus > 201103L |

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

554 | template<> |

555 | struct logical_and<void> |

556 | { |

557 | template <typename _Tp, typename _Up> |

558 | _GLIBCXX14_CONSTEXPR |

559 | auto |

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

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

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

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

564 | |

565 | typedef __is_transparent is_transparent; |

566 | }; |

567 | |

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

569 | template<> |

570 | struct logical_or<void> |

571 | { |

572 | template <typename _Tp, typename _Up> |

573 | _GLIBCXX14_CONSTEXPR |

574 | auto |

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

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

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

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

579 | |

580 | typedef __is_transparent is_transparent; |

581 | }; |

582 | |

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

584 | template<> |

585 | struct logical_not<void> |

586 | { |

587 | template <typename _Tp> |

588 | _GLIBCXX14_CONSTEXPR |

589 | auto |

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

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

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

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

594 | |

595 | typedef __is_transparent is_transparent; |

596 | }; |

597 | #endif |

598 | /** @} */ |

599 | |

600 | #if __cplusplus > 201103L |

601 | template<typename _Tp = void> |

602 | struct bit_and; |

603 | |

604 | template<typename _Tp = void> |

605 | struct bit_or; |

606 | |

607 | template<typename _Tp = void> |

608 | struct bit_xor; |

609 | |

610 | template<typename _Tp = void> |

611 | struct bit_not; |

612 | #endif |

613 | |

614 | // _GLIBCXX_RESOLVE_LIB_DEFECTS |

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

616 | template<typename _Tp> |

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

618 | { |

619 | _GLIBCXX14_CONSTEXPR |

620 | _Tp |

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

622 | { return __x & __y; } |

623 | }; |

624 | |

625 | template<typename _Tp> |

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

627 | { |

628 | _GLIBCXX14_CONSTEXPR |

629 | _Tp |

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

631 | { return __x | __y; } |

632 | }; |

633 | |

634 | template<typename _Tp> |

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

636 | { |

637 | _GLIBCXX14_CONSTEXPR |

638 | _Tp |

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

640 | { return __x ^ __y; } |

641 | }; |

642 | |

643 | template<typename _Tp> |

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

645 | { |

646 | _GLIBCXX14_CONSTEXPR |

647 | _Tp |

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

649 | { return ~__x; } |

650 | }; |

651 | |

652 | #if __cplusplus > 201103L |

653 | template <> |

654 | struct bit_and<void> |

655 | { |

656 | template <typename _Tp, typename _Up> |

657 | _GLIBCXX14_CONSTEXPR |

658 | auto |

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

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

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

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

663 | |

664 | typedef __is_transparent is_transparent; |

665 | }; |

666 | |

667 | template <> |

668 | struct bit_or<void> |

669 | { |

670 | template <typename _Tp, typename _Up> |

671 | _GLIBCXX14_CONSTEXPR |

672 | auto |

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

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

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

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

677 | |

678 | typedef __is_transparent is_transparent; |

679 | }; |

680 | |

681 | template <> |

682 | struct bit_xor<void> |

683 | { |

684 | template <typename _Tp, typename _Up> |

685 | _GLIBCXX14_CONSTEXPR |

686 | auto |

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

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

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

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

691 | |

692 | typedef __is_transparent is_transparent; |

693 | }; |

694 | |

695 | template <> |

696 | struct bit_not<void> |

697 | { |

698 | template <typename _Tp> |

699 | _GLIBCXX14_CONSTEXPR |

700 | auto |

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

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

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

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

705 | |

706 | typedef __is_transparent is_transparent; |

707 | }; |

708 | #endif |

709 | |

710 | // 20.3.5 negators |

711 | /** @defgroup negators Negators |

712 | * @ingroup functors |

713 | * |

714 | * The functions @c not1 and @c not2 each take a predicate functor |

715 | * and return an instance of @c unary_negate or |

716 | * @c binary_negate, respectively. These classes are functors whose |

717 | * @c operator() performs the stored predicate function and then returns |

718 | * the negation of the result. |

719 | * |

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

721 | * \code |

722 | * struct IntGreaterThanThree |

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

724 | * { |

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

726 | * }; |

727 | * |

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

729 | * \endcode |

730 | * The call to @c find_if will locate the first index (i) of @c v for which |

731 | * <code>!(v[i] > 3)</code> is true. |

732 | * |

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

734 | * argument. The not2/binary_negate combination works on predicates which |

735 | * take two arguments. |

736 | * |

737 | * @{ |

738 | */ |

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

740 | template<typename _Predicate> |

741 | class unary_negate |

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

743 | { |

744 | protected: |

745 | _Predicate _M_pred; |

746 | |

747 | public: |

748 | _GLIBCXX14_CONSTEXPR |

749 | explicit |

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

751 | |

752 | _GLIBCXX14_CONSTEXPR |

753 | bool |

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

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

756 | }; |

757 | |

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

759 | template<typename _Predicate> |

760 | _GLIBCXX14_CONSTEXPR |

761 | inline unary_negate<_Predicate> |

762 | not1(const _Predicate& __pred) |

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

764 | |

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

766 | template<typename _Predicate> |

767 | class binary_negate |

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

769 | typename _Predicate::second_argument_type, bool> |

770 | { |

771 | protected: |

772 | _Predicate _M_pred; |

773 | |

774 | public: |

775 | _GLIBCXX14_CONSTEXPR |

776 | explicit |

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

778 | |

779 | _GLIBCXX14_CONSTEXPR |

780 | bool |

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

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

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

784 | }; |

785 | |

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

787 | template<typename _Predicate> |

788 | _GLIBCXX14_CONSTEXPR |

789 | inline binary_negate<_Predicate> |

790 | not2(const _Predicate& __pred) |

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

792 | /** @} */ |

793 | |

794 | // 20.3.7 adaptors pointers functions |

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

796 | * @ingroup functors |

797 | * |

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

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

800 | * their argument and result types with uniform names (e.g., @c result_type |

801 | * from the base classes @c unary_function and @c binary_function). |

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

803 | * |

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

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

806 | * long-winded functor @c pointer_to_unary_function is constructed with a |

807 | * function pointer @c f, and its @c operator() called with argument @c x |

808 | * returns @c f(x). The functor @c pointer_to_binary_function does the same |

809 | * thing, but with a double-argument @c f and @c operator(). |

810 | * |

811 | * The function @c ptr_fun takes a pointer-to-function @c f and constructs |

812 | * an instance of the appropriate functor. |

813 | * |

814 | * @{ |

815 | */ |

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

817 | template<typename _Arg, typename _Result> |

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

819 | { |

820 | protected: |

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

822 | |

823 | public: |

824 | pointer_to_unary_function() { } |

825 | |

826 | explicit |

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

828 | : _M_ptr(__x) { } |

829 | |

830 | _Result |

831 | operator()(_Arg __x) const |

832 | { return _M_ptr(__x); } |

833 | }; |

834 | |

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

836 | template<typename _Arg, typename _Result> |

837 | inline pointer_to_unary_function<_Arg, _Result> |

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

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

840 | |

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

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

843 | class pointer_to_binary_function |

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

845 | { |

846 | protected: |

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

848 | |

849 | public: |

850 | pointer_to_binary_function() { } |

851 | |

852 | explicit |

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

854 | : _M_ptr(__x) { } |

855 | |

856 | _Result |

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

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

859 | }; |

860 | |

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

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

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

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

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

866 | /** @} */ |

867 | |

868 | template<typename _Tp> |

869 | struct _Identity |

870 | : public unary_function<_Tp, _Tp> |

871 | { |

872 | _Tp& |

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

874 | { return __x; } |

875 | |

876 | const _Tp& |

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

878 | { return __x; } |

879 | }; |

880 | |

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

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

883 | |

884 | template<typename _Pair> |

885 | struct _Select1st |

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

887 | { |

888 | typename _Pair::first_type& |

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

890 | { return __x.first; } |

891 | |

892 | const typename _Pair::first_type& |

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

894 | { return __x.first; } |

895 | |

896 | #if __cplusplus >= 201103L |

897 | template<typename _Pair2> |

898 | typename _Pair2::first_type& |

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

900 | { return __x.first; } |

901 | |

902 | template<typename _Pair2> |

903 | const typename _Pair2::first_type& |

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

905 | { return __x.first; } |

906 | #endif |

907 | }; |

908 | |

909 | template<typename _Pair> |

910 | struct _Select2nd |

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

912 | { |

913 | typename _Pair::second_type& |

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

915 | { return __x.second; } |

916 | |

917 | const typename _Pair::second_type& |

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

919 | { return __x.second; } |

920 | }; |

921 | |

922 | // 20.3.8 adaptors pointers members |

923 | /** @defgroup memory_adaptors Adaptors for pointers to members |

924 | * @ingroup functors |

925 | * |

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

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

928 | * one argument. |

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

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

931 | * |

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

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

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

935 | * |

936 | * @{ |

937 | */ |

938 | /// One of the @link memory_adaptors adaptors for member |

939 | /// pointers@endlink. |

940 | template<typename _Ret, typename _Tp> |

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

942 | { |

943 | public: |

944 | explicit |

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

946 | : _M_f(__pf) { } |

947 | |

948 | _Ret |

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

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

951 | |

952 | private: |

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

954 | }; |

955 | |

956 | /// One of the @link memory_adaptors adaptors for member |

957 | /// pointers@endlink. |

958 | template<typename _Ret, typename _Tp> |

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

960 | { |

961 | public: |

962 | explicit |

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

964 | : _M_f(__pf) { } |

965 | |

966 | _Ret |

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

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

969 | |

970 | private: |

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

972 | }; |

973 | |

974 | /// One of the @link memory_adaptors adaptors for member |

975 | /// pointers@endlink. |

976 | template<typename _Ret, typename _Tp> |

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

978 | { |

979 | public: |

980 | explicit |

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

982 | : _M_f(__pf) { } |

983 | |

984 | _Ret |

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

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

987 | |

988 | private: |

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

990 | }; |

991 | |

992 | /// One of the @link memory_adaptors adaptors for member |

993 | /// pointers@endlink. |

994 | template<typename _Ret, typename _Tp> |

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

996 | { |

997 | public: |

998 | explicit |

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

1000 | : _M_f(__pf) { } |

1001 | |

1002 | _Ret |

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

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

1005 | |

1006 | private: |

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

1008 | }; |

1009 | |

1010 | /// One of the @link memory_adaptors adaptors for member |

1011 | /// pointers@endlink. |

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

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

1014 | { |

1015 | public: |

1016 | explicit |

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

1018 | : _M_f(__pf) { } |

1019 | |

1020 | _Ret |

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

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

1023 | |

1024 | private: |

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

1026 | }; |

1027 | |

1028 | /// One of the @link memory_adaptors adaptors for member |

1029 | /// pointers@endlink. |

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

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

1032 | { |

1033 | public: |

1034 | explicit |

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

1036 | : _M_f(__pf) { } |

1037 | |

1038 | _Ret |

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

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

1041 | |

1042 | private: |

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

1044 | }; |

1045 | |

1046 | /// One of the @link memory_adaptors adaptors for member |

1047 | /// pointers@endlink. |

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

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

1050 | { |

1051 | public: |

1052 | explicit |

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

1054 | : _M_f(__pf) { } |

1055 | |

1056 | _Ret |

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

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

1059 | |

1060 | private: |

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

1062 | }; |

1063 | |

1064 | /// One of the @link memory_adaptors adaptors for member |

1065 | /// pointers@endlink. |

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

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

1068 | { |

1069 | public: |

1070 | explicit |

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

1072 | : _M_f(__pf) { } |

1073 | |

1074 | _Ret |

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

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

1077 | |

1078 | private: |

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

1080 | }; |

1081 | |

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

1083 | // mem_fun and mem_fun_ref. |

1084 | template<typename _Ret, typename _Tp> |

1085 | inline mem_fun_t<_Ret, _Tp> |

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

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

1088 | |

1089 | template<typename _Ret, typename _Tp> |

1090 | inline const_mem_fun_t<_Ret, _Tp> |

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

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

1093 | |

1094 | template<typename _Ret, typename _Tp> |

1095 | inline mem_fun_ref_t<_Ret, _Tp> |

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

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

1098 | |

1099 | template<typename _Ret, typename _Tp> |

1100 | inline const_mem_fun_ref_t<_Ret, _Tp> |

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

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

1103 | |

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

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

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

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

1108 | |

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

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

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

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

1113 | |

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

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

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

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

1118 | |

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

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

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

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

1123 | |

1124 | /** @} */ |

1125 | |

1126 | _GLIBCXX_END_NAMESPACE_VERSION |

1127 | } // namespace |

1128 | |

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

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

1131 | #endif |

1132 | |

1133 | #endif /* _STL_FUNCTION_H */ |

1134 |