1 | // Boost string_algo library replace.hpp header file ---------------------------// |
---|---|

2 | |

3 | // Copyright Pavol Droba 2002-2006. |

4 | // |

5 | // Distributed under the Boost Software License, Version 1.0. |

6 | // (See accompanying file LICENSE_1_0.txt or copy at |

7 | // http://www.boost.org/LICENSE_1_0.txt) |

8 | |

9 | // See http://www.boost.org/ for updates, documentation, and revision history. |

10 | |

11 | #ifndef BOOST_STRING_REPLACE_HPP |

12 | #define BOOST_STRING_REPLACE_HPP |

13 | |

14 | #include <boost/algorithm/string/config.hpp> |

15 | |

16 | #include <boost/range/iterator_range_core.hpp> |

17 | #include <boost/range/begin.hpp> |

18 | #include <boost/range/end.hpp> |

19 | #include <boost/range/iterator.hpp> |

20 | #include <boost/range/const_iterator.hpp> |

21 | |

22 | #include <boost/algorithm/string/find_format.hpp> |

23 | #include <boost/algorithm/string/finder.hpp> |

24 | #include <boost/algorithm/string/formatter.hpp> |

25 | #include <boost/algorithm/string/compare.hpp> |

26 | |

27 | /*! \file |

28 | Defines various replace algorithms. Each algorithm replaces |

29 | part(s) of the input according to set of searching and replace criteria. |

30 | */ |

31 | |

32 | namespace boost { |

33 | namespace algorithm { |

34 | |

35 | // replace_range --------------------------------------------------------------------// |

36 | |

37 | //! Replace range algorithm |

38 | /*! |

39 | Replace the given range in the input string. |

40 | The result is a modified copy of the input. It is returned as a sequence |

41 | or copied to the output iterator. |

42 | |

43 | \param Output An output iterator to which the result will be copied |

44 | \param Input An input string |

45 | \param SearchRange A range in the input to be substituted |

46 | \param Format A substitute string |

47 | \return An output iterator pointing just after the last inserted character or |

48 | a modified copy of the input |

49 | |

50 | \note The second variant of this function provides the strong exception-safety guarantee |

51 | */ |

52 | template< |

53 | typename OutputIteratorT, |

54 | typename Range1T, |

55 | typename Range2T> |

56 | inline OutputIteratorT replace_range_copy( |

57 | OutputIteratorT Output, |

58 | const Range1T& Input, |

59 | const iterator_range< |

60 | BOOST_STRING_TYPENAME |

61 | range_const_iterator<Range1T>::type>& SearchRange, |

62 | const Range2T& Format) |

63 | { |

64 | return ::boost::algorithm::find_format_copy( |

65 | Output, |

66 | Input, |

67 | ::boost::algorithm::range_finder(SearchRange), |

68 | ::boost::algorithm::const_formatter(Format)); |

69 | } |

70 | |

71 | //! Replace range algorithm |

72 | /*! |

73 | \overload |

74 | */ |

75 | template<typename SequenceT, typename RangeT> |

76 | inline SequenceT replace_range_copy( |

77 | const SequenceT& Input, |

78 | const iterator_range< |

79 | BOOST_STRING_TYPENAME |

80 | range_const_iterator<SequenceT>::type>& SearchRange, |

81 | const RangeT& Format) |

82 | { |

83 | return ::boost::algorithm::find_format_copy( |

84 | Input, |

85 | ::boost::algorithm::range_finder(SearchRange), |

86 | ::boost::algorithm::const_formatter(Format)); |

87 | } |

88 | |

89 | //! Replace range algorithm |

90 | /*! |

91 | Replace the given range in the input string. |

92 | The input sequence is modified in-place. |

93 | |

94 | \param Input An input string |

95 | \param SearchRange A range in the input to be substituted |

96 | \param Format A substitute string |

97 | */ |

98 | template<typename SequenceT, typename RangeT> |

99 | inline void replace_range( |

100 | SequenceT& Input, |

101 | const iterator_range< |

102 | BOOST_STRING_TYPENAME |

103 | range_iterator<SequenceT>::type>& SearchRange, |

104 | const RangeT& Format) |

105 | { |

106 | ::boost::algorithm::find_format( |

107 | Input, |

108 | ::boost::algorithm::range_finder(SearchRange), |

109 | ::boost::algorithm::const_formatter(Format)); |

110 | } |

111 | |

112 | // replace_first --------------------------------------------------------------------// |

113 | |

114 | //! Replace first algorithm |

115 | /*! |

116 | Replace the first match of the search substring in the input |

117 | with the format string. |

118 | The result is a modified copy of the input. It is returned as a sequence |

119 | or copied to the output iterator. |

120 | |

121 | \param Output An output iterator to which the result will be copied |

122 | \param Input An input string |

123 | \param Search A substring to be searched for |

124 | \param Format A substitute string |

125 | \return An output iterator pointing just after the last inserted character or |

126 | a modified copy of the input |

127 | |

128 | \note The second variant of this function provides the strong exception-safety guarantee |

129 | */ |

130 | template< |

131 | typename OutputIteratorT, |

132 | typename Range1T, |

133 | typename Range2T, |

134 | typename Range3T> |

135 | inline OutputIteratorT replace_first_copy( |

136 | OutputIteratorT Output, |

137 | const Range1T& Input, |

138 | const Range2T& Search, |

139 | const Range3T& Format) |

140 | { |

141 | return ::boost::algorithm::find_format_copy( |

142 | Output, |

143 | Input, |

144 | ::boost::algorithm::first_finder(Search), |

145 | ::boost::algorithm::const_formatter(Format) ); |

146 | } |

147 | |

148 | //! Replace first algorithm |

149 | /*! |

150 | \overload |

151 | */ |

152 | template<typename SequenceT, typename Range1T, typename Range2T> |

153 | inline SequenceT replace_first_copy( |

154 | const SequenceT& Input, |

155 | const Range1T& Search, |

156 | const Range2T& Format ) |

157 | { |

158 | return ::boost::algorithm::find_format_copy( |

159 | Input, |

160 | ::boost::algorithm::first_finder(Search), |

161 | ::boost::algorithm::const_formatter(Format) ); |

162 | } |

163 | |

164 | //! Replace first algorithm |

165 | /*! |

166 | replace the first match of the search substring in the input |

167 | with the format string. The input sequence is modified in-place. |

168 | |

169 | \param Input An input string |

170 | \param Search A substring to be searched for |

171 | \param Format A substitute string |

172 | */ |

173 | template<typename SequenceT, typename Range1T, typename Range2T> |

174 | inline void replace_first( |

175 | SequenceT& Input, |

176 | const Range1T& Search, |

177 | const Range2T& Format ) |

178 | { |

179 | ::boost::algorithm::find_format( |

180 | Input, |

181 | ::boost::algorithm::first_finder(Search), |

182 | ::boost::algorithm::const_formatter(Format) ); |

183 | } |

184 | |

185 | // replace_first ( case insensitive ) ---------------------------------------------// |

186 | |

187 | //! Replace first algorithm ( case insensitive ) |

188 | /*! |

189 | Replace the first match of the search substring in the input |

190 | with the format string. |

191 | The result is a modified copy of the input. It is returned as a sequence |

192 | or copied to the output iterator. |

193 | Searching is case insensitive. |

194 | |

195 | \param Output An output iterator to which the result will be copied |

196 | \param Input An input string |

197 | \param Search A substring to be searched for |

198 | \param Format A substitute string |

199 | \param Loc A locale used for case insensitive comparison |

200 | \return An output iterator pointing just after the last inserted character or |

201 | a modified copy of the input |

202 | |

203 | \note The second variant of this function provides the strong exception-safety guarantee |

204 | */ |

205 | template< |

206 | typename OutputIteratorT, |

207 | typename Range1T, |

208 | typename Range2T, |

209 | typename Range3T> |

210 | inline OutputIteratorT ireplace_first_copy( |

211 | OutputIteratorT Output, |

212 | const Range1T& Input, |

213 | const Range2T& Search, |

214 | const Range3T& Format, |

215 | const std::locale& Loc=std::locale() ) |

216 | { |

217 | return ::boost::algorithm::find_format_copy( |

218 | Output, |

219 | Input, |

220 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

221 | ::boost::algorithm::const_formatter(Format) ); |

222 | } |

223 | |

224 | //! Replace first algorithm ( case insensitive ) |

225 | /*! |

226 | \overload |

227 | */ |

228 | template<typename SequenceT, typename Range2T, typename Range1T> |

229 | inline SequenceT ireplace_first_copy( |

230 | const SequenceT& Input, |

231 | const Range2T& Search, |

232 | const Range1T& Format, |

233 | const std::locale& Loc=std::locale() ) |

234 | { |

235 | return ::boost::algorithm::find_format_copy( |

236 | Input, |

237 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

238 | ::boost::algorithm::const_formatter(Format) ); |

239 | } |

240 | |

241 | //! Replace first algorithm ( case insensitive ) |

242 | /*! |

243 | Replace the first match of the search substring in the input |

244 | with the format string. Input sequence is modified in-place. |

245 | Searching is case insensitive. |

246 | |

247 | \param Input An input string |

248 | \param Search A substring to be searched for |

249 | \param Format A substitute string |

250 | \param Loc A locale used for case insensitive comparison |

251 | */ |

252 | template<typename SequenceT, typename Range1T, typename Range2T> |

253 | inline void ireplace_first( |

254 | SequenceT& Input, |

255 | const Range1T& Search, |

256 | const Range2T& Format, |

257 | const std::locale& Loc=std::locale() ) |

258 | { |

259 | ::boost::algorithm::find_format( |

260 | Input, |

261 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

262 | ::boost::algorithm::const_formatter(Format) ); |

263 | } |

264 | |

265 | // replace_last --------------------------------------------------------------------// |

266 | |

267 | //! Replace last algorithm |

268 | /*! |

269 | Replace the last match of the search string in the input |

270 | with the format string. |

271 | The result is a modified copy of the input. It is returned as a sequence |

272 | or copied to the output iterator. |

273 | |

274 | \param Output An output iterator to which the result will be copied |

275 | \param Input An input string |

276 | \param Search A substring to be searched for |

277 | \param Format A substitute string |

278 | \return An output iterator pointing just after the last inserted character or |

279 | a modified copy of the input |

280 | |

281 | \note The second variant of this function provides the strong exception-safety guarantee |

282 | */ |

283 | template< |

284 | typename OutputIteratorT, |

285 | typename Range1T, |

286 | typename Range2T, |

287 | typename Range3T> |

288 | inline OutputIteratorT replace_last_copy( |

289 | OutputIteratorT Output, |

290 | const Range1T& Input, |

291 | const Range2T& Search, |

292 | const Range3T& Format ) |

293 | { |

294 | return ::boost::algorithm::find_format_copy( |

295 | Output, |

296 | Input, |

297 | ::boost::algorithm::last_finder(Search), |

298 | ::boost::algorithm::const_formatter(Format) ); |

299 | } |

300 | |

301 | //! Replace last algorithm |

302 | /*! |

303 | \overload |

304 | */ |

305 | template<typename SequenceT, typename Range1T, typename Range2T> |

306 | inline SequenceT replace_last_copy( |

307 | const SequenceT& Input, |

308 | const Range1T& Search, |

309 | const Range2T& Format ) |

310 | { |

311 | return ::boost::algorithm::find_format_copy( |

312 | Input, |

313 | ::boost::algorithm::last_finder(Search), |

314 | ::boost::algorithm::const_formatter(Format) ); |

315 | } |

316 | |

317 | //! Replace last algorithm |

318 | /*! |

319 | Replace the last match of the search string in the input |

320 | with the format string. Input sequence is modified in-place. |

321 | |

322 | \param Input An input string |

323 | \param Search A substring to be searched for |

324 | \param Format A substitute string |

325 | */ |

326 | template<typename SequenceT, typename Range1T, typename Range2T> |

327 | inline void replace_last( |

328 | SequenceT& Input, |

329 | const Range1T& Search, |

330 | const Range2T& Format ) |

331 | { |

332 | ::boost::algorithm::find_format( |

333 | Input, |

334 | ::boost::algorithm::last_finder(Search), |

335 | ::boost::algorithm::const_formatter(Format) ); |

336 | } |

337 | |

338 | // replace_last ( case insensitive ) -----------------------------------------------// |

339 | |

340 | //! Replace last algorithm ( case insensitive ) |

341 | /*! |

342 | Replace the last match of the search string in the input |

343 | with the format string. |

344 | The result is a modified copy of the input. It is returned as a sequence |

345 | or copied to the output iterator. |

346 | Searching is case insensitive. |

347 | |

348 | \param Output An output iterator to which the result will be copied |

349 | \param Input An input string |

350 | \param Search A substring to be searched for |

351 | \param Format A substitute string |

352 | \param Loc A locale used for case insensitive comparison |

353 | \return An output iterator pointing just after the last inserted character or |

354 | a modified copy of the input |

355 | |

356 | \note The second variant of this function provides the strong exception-safety guarantee |

357 | */ |

358 | template< |

359 | typename OutputIteratorT, |

360 | typename Range1T, |

361 | typename Range2T, |

362 | typename Range3T> |

363 | inline OutputIteratorT ireplace_last_copy( |

364 | OutputIteratorT Output, |

365 | const Range1T& Input, |

366 | const Range2T& Search, |

367 | const Range3T& Format, |

368 | const std::locale& Loc=std::locale() ) |

369 | { |

370 | return ::boost::algorithm::find_format_copy( |

371 | Output, |

372 | Input, |

373 | ::boost::algorithm::last_finder(Search, is_iequal(Loc)), |

374 | ::boost::algorithm::const_formatter(Format) ); |

375 | } |

376 | |

377 | //! Replace last algorithm ( case insensitive ) |

378 | /*! |

379 | \overload |

380 | */ |

381 | template<typename SequenceT, typename Range1T, typename Range2T> |

382 | inline SequenceT ireplace_last_copy( |

383 | const SequenceT& Input, |

384 | const Range1T& Search, |

385 | const Range2T& Format, |

386 | const std::locale& Loc=std::locale() ) |

387 | { |

388 | return ::boost::algorithm::find_format_copy( |

389 | Input, |

390 | ::boost::algorithm::last_finder(Search, is_iequal(Loc)), |

391 | ::boost::algorithm::const_formatter(Format) ); |

392 | } |

393 | |

394 | //! Replace last algorithm ( case insensitive ) |

395 | /*! |

396 | Replace the last match of the search string in the input |

397 | with the format string.The input sequence is modified in-place. |

398 | Searching is case insensitive. |

399 | |

400 | \param Input An input string |

401 | \param Search A substring to be searched for |

402 | \param Format A substitute string |

403 | \param Loc A locale used for case insensitive comparison |

404 | \return A reference to the modified input |

405 | */ |

406 | template<typename SequenceT, typename Range1T, typename Range2T> |

407 | inline void ireplace_last( |

408 | SequenceT& Input, |

409 | const Range1T& Search, |

410 | const Range2T& Format, |

411 | const std::locale& Loc=std::locale() ) |

412 | { |

413 | ::boost::algorithm::find_format( |

414 | Input, |

415 | ::boost::algorithm::last_finder(Search, is_iequal(Loc)), |

416 | ::boost::algorithm::const_formatter(Format) ); |

417 | } |

418 | |

419 | // replace_nth --------------------------------------------------------------------// |

420 | |

421 | //! Replace nth algorithm |

422 | /*! |

423 | Replace an Nth (zero-indexed) match of the search string in the input |

424 | with the format string. |

425 | The result is a modified copy of the input. It is returned as a sequence |

426 | or copied to the output iterator. |

427 | |

428 | \param Output An output iterator to which the result will be copied |

429 | \param Input An input string |

430 | \param Search A substring to be searched for |

431 | \param Nth An index of the match to be replaced. The index is 0-based. |

432 | For negative N, matches are counted from the end of string. |

433 | \param Format A substitute string |

434 | \return An output iterator pointing just after the last inserted character or |

435 | a modified copy of the input |

436 | |

437 | \note The second variant of this function provides the strong exception-safety guarantee |

438 | */ |

439 | template< |

440 | typename OutputIteratorT, |

441 | typename Range1T, |

442 | typename Range2T, |

443 | typename Range3T> |

444 | inline OutputIteratorT replace_nth_copy( |

445 | OutputIteratorT Output, |

446 | const Range1T& Input, |

447 | const Range2T& Search, |

448 | int Nth, |

449 | const Range3T& Format ) |

450 | { |

451 | return ::boost::algorithm::find_format_copy( |

452 | Output, |

453 | Input, |

454 | ::boost::algorithm::nth_finder(Search, Nth), |

455 | ::boost::algorithm::const_formatter(Format) ); |

456 | } |

457 | |

458 | //! Replace nth algorithm |

459 | /*! |

460 | \overload |

461 | */ |

462 | template<typename SequenceT, typename Range1T, typename Range2T> |

463 | inline SequenceT replace_nth_copy( |

464 | const SequenceT& Input, |

465 | const Range1T& Search, |

466 | int Nth, |

467 | const Range2T& Format ) |

468 | { |

469 | return ::boost::algorithm::find_format_copy( |

470 | Input, |

471 | ::boost::algorithm::nth_finder(Search, Nth), |

472 | ::boost::algorithm::const_formatter(Format) ); |

473 | } |

474 | |

475 | //! Replace nth algorithm |

476 | /*! |

477 | Replace an Nth (zero-indexed) match of the search string in the input |

478 | with the format string. Input sequence is modified in-place. |

479 | |

480 | \param Input An input string |

481 | \param Search A substring to be searched for |

482 | \param Nth An index of the match to be replaced. The index is 0-based. |

483 | For negative N, matches are counted from the end of string. |

484 | \param Format A substitute string |

485 | */ |

486 | template<typename SequenceT, typename Range1T, typename Range2T> |

487 | inline void replace_nth( |

488 | SequenceT& Input, |

489 | const Range1T& Search, |

490 | int Nth, |

491 | const Range2T& Format ) |

492 | { |

493 | ::boost::algorithm::find_format( |

494 | Input, |

495 | ::boost::algorithm::nth_finder(Search, Nth), |

496 | ::boost::algorithm::const_formatter(Format) ); |

497 | } |

498 | |

499 | // replace_nth ( case insensitive ) -----------------------------------------------// |

500 | |

501 | //! Replace nth algorithm ( case insensitive ) |

502 | /*! |

503 | Replace an Nth (zero-indexed) match of the search string in the input |

504 | with the format string. |

505 | The result is a modified copy of the input. It is returned as a sequence |

506 | or copied to the output iterator. |

507 | Searching is case insensitive. |

508 | |

509 | \param Output An output iterator to which the result will be copied |

510 | \param Input An input string |

511 | \param Search A substring to be searched for |

512 | \param Nth An index of the match to be replaced. The index is 0-based. |

513 | For negative N, matches are counted from the end of string. |

514 | \param Format A substitute string |

515 | \param Loc A locale used for case insensitive comparison |

516 | \return An output iterator pointing just after the last inserted character or |

517 | a modified copy of the input |

518 | |

519 | \note The second variant of this function provides the strong exception-safety guarantee |

520 | */ |

521 | template< |

522 | typename OutputIteratorT, |

523 | typename Range1T, |

524 | typename Range2T, |

525 | typename Range3T> |

526 | inline OutputIteratorT ireplace_nth_copy( |

527 | OutputIteratorT Output, |

528 | const Range1T& Input, |

529 | const Range2T& Search, |

530 | int Nth, |

531 | const Range3T& Format, |

532 | const std::locale& Loc=std::locale() ) |

533 | { |

534 | return ::boost::algorithm::find_format_copy( |

535 | Output, |

536 | Input, |

537 | ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ), |

538 | ::boost::algorithm::const_formatter(Format) ); |

539 | } |

540 | |

541 | //! Replace nth algorithm ( case insensitive ) |

542 | /*! |

543 | \overload |

544 | */ |

545 | template<typename SequenceT, typename Range1T, typename Range2T> |

546 | inline SequenceT ireplace_nth_copy( |

547 | const SequenceT& Input, |

548 | const Range1T& Search, |

549 | int Nth, |

550 | const Range2T& Format, |

551 | const std::locale& Loc=std::locale() ) |

552 | { |

553 | return ::boost::algorithm::find_format_copy( |

554 | Input, |

555 | ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), |

556 | ::boost::algorithm::const_formatter(Format) ); |

557 | } |

558 | |

559 | //! Replace nth algorithm ( case insensitive ) |

560 | /*! |

561 | Replace an Nth (zero-indexed) match of the search string in the input |

562 | with the format string. Input sequence is modified in-place. |

563 | Searching is case insensitive. |

564 | |

565 | \param Input An input string |

566 | \param Search A substring to be searched for |

567 | \param Nth An index of the match to be replaced. The index is 0-based. |

568 | For negative N, matches are counted from the end of string. |

569 | \param Format A substitute string |

570 | \param Loc A locale used for case insensitive comparison |

571 | */ |

572 | template<typename SequenceT, typename Range1T, typename Range2T> |

573 | inline void ireplace_nth( |

574 | SequenceT& Input, |

575 | const Range1T& Search, |

576 | int Nth, |

577 | const Range2T& Format, |

578 | const std::locale& Loc=std::locale() ) |

579 | { |

580 | ::boost::algorithm::find_format( |

581 | Input, |

582 | ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), |

583 | ::boost::algorithm::const_formatter(Format) ); |

584 | } |

585 | |

586 | // replace_all --------------------------------------------------------------------// |

587 | |

588 | //! Replace all algorithm |

589 | /*! |

590 | Replace all occurrences of the search string in the input |

591 | with the format string. |

592 | The result is a modified copy of the input. It is returned as a sequence |

593 | or copied to the output iterator. |

594 | |

595 | \param Output An output iterator to which the result will be copied |

596 | \param Input An input string |

597 | \param Search A substring to be searched for |

598 | \param Format A substitute string |

599 | \return An output iterator pointing just after the last inserted character or |

600 | a modified copy of the input |

601 | |

602 | \note The second variant of this function provides the strong exception-safety guarantee |

603 | */ |

604 | template< |

605 | typename OutputIteratorT, |

606 | typename Range1T, |

607 | typename Range2T, |

608 | typename Range3T> |

609 | inline OutputIteratorT replace_all_copy( |

610 | OutputIteratorT Output, |

611 | const Range1T& Input, |

612 | const Range2T& Search, |

613 | const Range3T& Format ) |

614 | { |

615 | return ::boost::algorithm::find_format_all_copy( |

616 | Output, |

617 | Input, |

618 | ::boost::algorithm::first_finder(Search), |

619 | ::boost::algorithm::const_formatter(Format) ); |

620 | } |

621 | |

622 | //! Replace all algorithm |

623 | /*! |

624 | \overload |

625 | */ |

626 | template<typename SequenceT, typename Range1T, typename Range2T> |

627 | inline SequenceT replace_all_copy( |

628 | const SequenceT& Input, |

629 | const Range1T& Search, |

630 | const Range2T& Format ) |

631 | { |

632 | return ::boost::algorithm::find_format_all_copy( |

633 | Input, |

634 | ::boost::algorithm::first_finder(Search), |

635 | ::boost::algorithm::const_formatter(Format) ); |

636 | } |

637 | |

638 | //! Replace all algorithm |

639 | /*! |

640 | Replace all occurrences of the search string in the input |

641 | with the format string. The input sequence is modified in-place. |

642 | |

643 | \param Input An input string |

644 | \param Search A substring to be searched for |

645 | \param Format A substitute string |

646 | \return A reference to the modified input |

647 | */ |

648 | template<typename SequenceT, typename Range1T, typename Range2T> |

649 | inline void replace_all( |

650 | SequenceT& Input, |

651 | const Range1T& Search, |

652 | const Range2T& Format ) |

653 | { |

654 | ::boost::algorithm::find_format_all( |

655 | Input, |

656 | ::boost::algorithm::first_finder(Search), |

657 | ::boost::algorithm::const_formatter(Format) ); |

658 | } |

659 | |

660 | // replace_all ( case insensitive ) -----------------------------------------------// |

661 | |

662 | //! Replace all algorithm ( case insensitive ) |

663 | /*! |

664 | Replace all occurrences of the search string in the input |

665 | with the format string. |

666 | The result is a modified copy of the input. It is returned as a sequence |

667 | or copied to the output iterator. |

668 | Searching is case insensitive. |

669 | |

670 | \param Output An output iterator to which the result will be copied |

671 | \param Input An input string |

672 | \param Search A substring to be searched for |

673 | \param Format A substitute string |

674 | \param Loc A locale used for case insensitive comparison |

675 | \return An output iterator pointing just after the last inserted character or |

676 | a modified copy of the input |

677 | |

678 | \note The second variant of this function provides the strong exception-safety guarantee |

679 | */ |

680 | template< |

681 | typename OutputIteratorT, |

682 | typename Range1T, |

683 | typename Range2T, |

684 | typename Range3T> |

685 | inline OutputIteratorT ireplace_all_copy( |

686 | OutputIteratorT Output, |

687 | const Range1T& Input, |

688 | const Range2T& Search, |

689 | const Range3T& Format, |

690 | const std::locale& Loc=std::locale() ) |

691 | { |

692 | return ::boost::algorithm::find_format_all_copy( |

693 | Output, |

694 | Input, |

695 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

696 | ::boost::algorithm::const_formatter(Format) ); |

697 | } |

698 | |

699 | //! Replace all algorithm ( case insensitive ) |

700 | /*! |

701 | \overload |

702 | */ |

703 | template<typename SequenceT, typename Range1T, typename Range2T> |

704 | inline SequenceT ireplace_all_copy( |

705 | const SequenceT& Input, |

706 | const Range1T& Search, |

707 | const Range2T& Format, |

708 | const std::locale& Loc=std::locale() ) |

709 | { |

710 | return ::boost::algorithm::find_format_all_copy( |

711 | Input, |

712 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

713 | ::boost::algorithm::const_formatter(Format) ); |

714 | } |

715 | |

716 | //! Replace all algorithm ( case insensitive ) |

717 | /*! |

718 | Replace all occurrences of the search string in the input |

719 | with the format string.The input sequence is modified in-place. |

720 | Searching is case insensitive. |

721 | |

722 | \param Input An input string |

723 | \param Search A substring to be searched for |

724 | \param Format A substitute string |

725 | \param Loc A locale used for case insensitive comparison |

726 | */ |

727 | template<typename SequenceT, typename Range1T, typename Range2T> |

728 | inline void ireplace_all( |

729 | SequenceT& Input, |

730 | const Range1T& Search, |

731 | const Range2T& Format, |

732 | const std::locale& Loc=std::locale() ) |

733 | { |

734 | ::boost::algorithm::find_format_all( |

735 | Input, |

736 | ::boost::algorithm::first_finder(Search, is_iequal(Loc)), |

737 | ::boost::algorithm::const_formatter(Format) ); |

738 | } |

739 | |

740 | // replace_head --------------------------------------------------------------------// |

741 | |

742 | //! Replace head algorithm |

743 | /*! |

744 | Replace the head of the input with the given format string. |

745 | The head is a prefix of a string of given size. |

746 | If the sequence is shorter then required, whole string if |

747 | considered to be the head. |

748 | The result is a modified copy of the input. It is returned as a sequence |

749 | or copied to the output iterator. |

750 | |

751 | \param Output An output iterator to which the result will be copied |

752 | \param Input An input string |

753 | \param N Length of the head. |

754 | For N>=0, at most N characters are extracted. |

755 | For N<0, size(Input)-|N| characters are extracted. |

756 | \param Format A substitute string |

757 | \return An output iterator pointing just after the last inserted character or |

758 | a modified copy of the input |

759 | |

760 | \note The second variant of this function provides the strong exception-safety guarantee |

761 | */ |

762 | template< |

763 | typename OutputIteratorT, |

764 | typename Range1T, |

765 | typename Range2T> |

766 | inline OutputIteratorT replace_head_copy( |

767 | OutputIteratorT Output, |

768 | const Range1T& Input, |

769 | int N, |

770 | const Range2T& Format ) |

771 | { |

772 | return ::boost::algorithm::find_format_copy( |

773 | Output, |

774 | Input, |

775 | ::boost::algorithm::head_finder(N), |

776 | ::boost::algorithm::const_formatter(Format) ); |

777 | } |

778 | |

779 | //! Replace head algorithm |

780 | /*! |

781 | \overload |

782 | */ |

783 | template<typename SequenceT, typename RangeT> |

784 | inline SequenceT replace_head_copy( |

785 | const SequenceT& Input, |

786 | int N, |

787 | const RangeT& Format ) |

788 | { |

789 | return ::boost::algorithm::find_format_copy( |

790 | Input, |

791 | ::boost::algorithm::head_finder(N), |

792 | ::boost::algorithm::const_formatter(Format) ); |

793 | } |

794 | |

795 | //! Replace head algorithm |

796 | /*! |

797 | Replace the head of the input with the given format string. |

798 | The head is a prefix of a string of given size. |

799 | If the sequence is shorter then required, the whole string is |

800 | considered to be the head. The input sequence is modified in-place. |

801 | |

802 | \param Input An input string |

803 | \param N Length of the head. |

804 | For N>=0, at most N characters are extracted. |

805 | For N<0, size(Input)-|N| characters are extracted. |

806 | \param Format A substitute string |

807 | */ |

808 | template<typename SequenceT, typename RangeT> |

809 | inline void replace_head( |

810 | SequenceT& Input, |

811 | int N, |

812 | const RangeT& Format ) |

813 | { |

814 | ::boost::algorithm::find_format( |

815 | Input, |

816 | ::boost::algorithm::head_finder(N), |

817 | ::boost::algorithm::const_formatter(Format) ); |

818 | } |

819 | |

820 | // replace_tail --------------------------------------------------------------------// |

821 | |

822 | //! Replace tail algorithm |

823 | /*! |

824 | Replace the tail of the input with the given format string. |

825 | The tail is a suffix of a string of given size. |

826 | If the sequence is shorter then required, whole string is |

827 | considered to be the tail. |

828 | The result is a modified copy of the input. It is returned as a sequence |

829 | or copied to the output iterator. |

830 | |

831 | \param Output An output iterator to which the result will be copied |

832 | \param Input An input string |

833 | \param N Length of the tail. |

834 | For N>=0, at most N characters are extracted. |

835 | For N<0, size(Input)-|N| characters are extracted. |

836 | \param Format A substitute string |

837 | \return An output iterator pointing just after the last inserted character or |

838 | a modified copy of the input |

839 | |

840 | \note The second variant of this function provides the strong exception-safety guarantee |

841 | */ |

842 | template< |

843 | typename OutputIteratorT, |

844 | typename Range1T, |

845 | typename Range2T> |

846 | inline OutputIteratorT replace_tail_copy( |

847 | OutputIteratorT Output, |

848 | const Range1T& Input, |

849 | int N, |

850 | const Range2T& Format ) |

851 | { |

852 | return ::boost::algorithm::find_format_copy( |

853 | Output, |

854 | Input, |

855 | ::boost::algorithm::tail_finder(N), |

856 | ::boost::algorithm::const_formatter(Format) ); |

857 | } |

858 | |

859 | //! Replace tail algorithm |

860 | /*! |

861 | \overload |

862 | */ |

863 | template<typename SequenceT, typename RangeT> |

864 | inline SequenceT replace_tail_copy( |

865 | const SequenceT& Input, |

866 | int N, |

867 | const RangeT& Format ) |

868 | { |

869 | return ::boost::algorithm::find_format_copy( |

870 | Input, |

871 | ::boost::algorithm::tail_finder(N), |

872 | ::boost::algorithm::const_formatter(Format) ); |

873 | } |

874 | |

875 | //! Replace tail algorithm |

876 | /*! |

877 | Replace the tail of the input with the given format sequence. |

878 | The tail is a suffix of a string of given size. |

879 | If the sequence is shorter then required, the whole string is |

880 | considered to be the tail. The input sequence is modified in-place. |

881 | |

882 | \param Input An input string |

883 | \param N Length of the tail. |

884 | For N>=0, at most N characters are extracted. |

885 | For N<0, size(Input)-|N| characters are extracted. |

886 | \param Format A substitute string |

887 | */ |

888 | template<typename SequenceT, typename RangeT> |

889 | inline void replace_tail( |

890 | SequenceT& Input, |

891 | int N, |

892 | const RangeT& Format ) |

893 | { |

894 | ::boost::algorithm::find_format( |

895 | Input, |

896 | ::boost::algorithm::tail_finder(N), |

897 | ::boost::algorithm::const_formatter(Format) ); |

898 | } |

899 | |

900 | } // namespace algorithm |

901 | |

902 | // pull names to the boost namespace |

903 | using algorithm::replace_range_copy; |

904 | using algorithm::replace_range; |

905 | using algorithm::replace_first_copy; |

906 | using algorithm::replace_first; |

907 | using algorithm::ireplace_first_copy; |

908 | using algorithm::ireplace_first; |

909 | using algorithm::replace_last_copy; |

910 | using algorithm::replace_last; |

911 | using algorithm::ireplace_last_copy; |

912 | using algorithm::ireplace_last; |

913 | using algorithm::replace_nth_copy; |

914 | using algorithm::replace_nth; |

915 | using algorithm::ireplace_nth_copy; |

916 | using algorithm::ireplace_nth; |

917 | using algorithm::replace_all_copy; |

918 | using algorithm::replace_all; |

919 | using algorithm::ireplace_all_copy; |

920 | using algorithm::ireplace_all; |

921 | using algorithm::replace_head_copy; |

922 | using algorithm::replace_head; |

923 | using algorithm::replace_tail_copy; |

924 | using algorithm::replace_tail; |

925 | |

926 | } // namespace boost |

927 | |

928 | #endif // BOOST_REPLACE_HPP |

929 |