You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
928 lines
35 KiB
928 lines
35 KiB
// Boost string_algo library replace.hpp header file ---------------------------// |
|
|
|
// Copyright Pavol Droba 2002-2006. |
|
// |
|
// Distributed under the Boost Software License, Version 1.0. |
|
// (See accompanying file LICENSE_1_0.txt or copy at |
|
// http://www.boost.org/LICENSE_1_0.txt) |
|
|
|
// See http://www.boost.org/ for updates, documentation, and revision history. |
|
|
|
#ifndef BOOST_STRING_REPLACE_HPP |
|
#define BOOST_STRING_REPLACE_HPP |
|
|
|
#include <boost/algorithm/string/config.hpp> |
|
|
|
#include <boost/range/iterator_range.hpp> |
|
#include <boost/range/begin.hpp> |
|
#include <boost/range/end.hpp> |
|
#include <boost/range/iterator.hpp> |
|
#include <boost/range/const_iterator.hpp> |
|
|
|
#include <boost/algorithm/string/find_format.hpp> |
|
#include <boost/algorithm/string/finder.hpp> |
|
#include <boost/algorithm/string/formatter.hpp> |
|
#include <boost/algorithm/string/compare.hpp> |
|
|
|
/*! \file |
|
Defines various replace algorithms. Each algorithm replaces |
|
part(s) of the input according to set of searching and replace criteria. |
|
*/ |
|
|
|
namespace boost { |
|
namespace algorithm { |
|
|
|
// replace_range --------------------------------------------------------------------// |
|
|
|
//! Replace range algorithm |
|
/*! |
|
Replace the given range in the input string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param SearchRange A range in the input to be substituted |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T> |
|
inline OutputIteratorT replace_range_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const iterator_range< |
|
BOOST_STRING_TYPENAME |
|
range_const_iterator<Range1T>::type>& SearchRange, |
|
const Range2T& Format) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::range_finder(SearchRange), |
|
::boost::algorithm::const_formatter(Format)); |
|
} |
|
|
|
//! Replace range algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline SequenceT replace_range_copy( |
|
const SequenceT& Input, |
|
const iterator_range< |
|
BOOST_STRING_TYPENAME |
|
range_const_iterator<SequenceT>::type>& SearchRange, |
|
const RangeT& Format) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::range_finder(SearchRange), |
|
::boost::algorithm::const_formatter(Format)); |
|
} |
|
|
|
//! Replace range algorithm |
|
/*! |
|
Replace the given range in the input string. |
|
The input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param SearchRange A range in the input to be substituted |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline void replace_range( |
|
SequenceT& Input, |
|
const iterator_range< |
|
BOOST_STRING_TYPENAME |
|
range_iterator<SequenceT>::type>& SearchRange, |
|
const RangeT& Format) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::range_finder(SearchRange), |
|
::boost::algorithm::const_formatter(Format)); |
|
} |
|
|
|
// replace_first --------------------------------------------------------------------// |
|
|
|
//! Replace first algorithm |
|
/*! |
|
Replace the first match of the search substring in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT replace_first_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace first algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT replace_first_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace first algorithm |
|
/*! |
|
replace the first match of the search substring in the input |
|
with the format string. The input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void replace_first( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_first ( case insensitive ) ---------------------------------------------// |
|
|
|
//! Replace first algorithm ( case insensitive ) |
|
/*! |
|
Replace the first match of the search substring in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
Searching is case insensitive. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT ireplace_first_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace first algorithm ( case insensitive ) |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range2T, typename Range1T> |
|
inline SequenceT ireplace_first_copy( |
|
const SequenceT& Input, |
|
const Range2T& Search, |
|
const Range1T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace first algorithm ( case insensitive ) |
|
/*! |
|
Replace the first match of the search substring in the input |
|
with the format string. Input sequence is modified in-place. |
|
Searching is case insensitive. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void ireplace_first( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_last --------------------------------------------------------------------// |
|
|
|
//! Replace last algorithm |
|
/*! |
|
Replace the last match of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT replace_last_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::last_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace last algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT replace_last_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::last_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace last algorithm |
|
/*! |
|
Replace the last match of the search string in the input |
|
with the format string. Input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void replace_last( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::last_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_last ( case insensitive ) -----------------------------------------------// |
|
|
|
//! Replace last algorithm ( case insensitive ) |
|
/*! |
|
Replace the last match of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
Searching is case insensitive. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT ireplace_last_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::last_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace last algorithm ( case insensitive ) |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT ireplace_last_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::last_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace last algorithm ( case insensitive ) |
|
/*! |
|
Replace the last match of the search string in the input |
|
with the format string.The input sequence is modified in-place. |
|
Searching is case insensitive. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
\return A reference to the modified input |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void ireplace_last( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::last_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_nth --------------------------------------------------------------------// |
|
|
|
//! Replace nth algorithm |
|
/*! |
|
Replace an Nth (zero-indexed) match of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Nth An index of the match to be replaced. The index is 0-based. |
|
For negative N, matches are counted from the end of string. |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT replace_nth_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
int Nth, |
|
const Range3T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace nth algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT replace_nth_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
int Nth, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace nth algorithm |
|
/*! |
|
Replace an Nth (zero-indexed) match of the search string in the input |
|
with the format string. Input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Nth An index of the match to be replaced. The index is 0-based. |
|
For negative N, matches are counted from the end of string. |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void replace_nth( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
int Nth, |
|
const Range2T& Format ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_nth ( case insensitive ) -----------------------------------------------// |
|
|
|
//! Replace nth algorithm ( case insensitive ) |
|
/*! |
|
Replace an Nth (zero-indexed) match of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
Searching is case insensitive. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Nth An index of the match to be replaced. The index is 0-based. |
|
For negative N, matches are counted from the end of string. |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT ireplace_nth_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
int Nth, |
|
const Range3T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace nth algorithm ( case insensitive ) |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT ireplace_nth_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
int Nth, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace nth algorithm ( case insensitive ) |
|
/*! |
|
Replace an Nth (zero-indexed) match of the search string in the input |
|
with the format string. Input sequence is modified in-place. |
|
Searching is case insensitive. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Nth An index of the match to be replaced. The index is 0-based. |
|
For negative N, matches are counted from the end of string. |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void ireplace_nth( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
int Nth, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_all --------------------------------------------------------------------// |
|
|
|
//! Replace all algorithm |
|
/*! |
|
Replace all occurrences of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT replace_all_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_all_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace all algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT replace_all_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_all_copy( |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace all algorithm |
|
/*! |
|
Replace all occurrences of the search string in the input |
|
with the format string. The input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\return A reference to the modified input |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void replace_all( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format ) |
|
{ |
|
::boost::algorithm::find_format_all( |
|
Input, |
|
::boost::algorithm::first_finder(Search), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_all ( case insensitive ) -----------------------------------------------// |
|
|
|
//! Replace all algorithm ( case insensitive ) |
|
/*! |
|
Replace all occurrences of the search string in the input |
|
with the format string. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
Searching is case insensitive. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T, |
|
typename Range3T> |
|
inline OutputIteratorT ireplace_all_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
const Range2T& Search, |
|
const Range3T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_all_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace all algorithm ( case insensitive ) |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline SequenceT ireplace_all_copy( |
|
const SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
return ::boost::algorithm::find_format_all_copy( |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace all algorithm ( case insensitive ) |
|
/*! |
|
Replace all occurrences of the search string in the input |
|
with the format string.The input sequence is modified in-place. |
|
Searching is case insensitive. |
|
|
|
\param Input An input string |
|
\param Search A substring to be searched for |
|
\param Format A substitute string |
|
\param Loc A locale used for case insensitive comparison |
|
*/ |
|
template<typename SequenceT, typename Range1T, typename Range2T> |
|
inline void ireplace_all( |
|
SequenceT& Input, |
|
const Range1T& Search, |
|
const Range2T& Format, |
|
const std::locale& Loc=std::locale() ) |
|
{ |
|
::boost::algorithm::find_format_all( |
|
Input, |
|
::boost::algorithm::first_finder(Search, is_iequal(Loc)), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_head --------------------------------------------------------------------// |
|
|
|
//! Replace head algorithm |
|
/*! |
|
Replace the head of the input with the given format string. |
|
The head is a prefix of a string of given size. |
|
If the sequence is shorter then required, whole string if |
|
considered to be the head. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param N Length of the head. |
|
For N>=0, at most N characters are extracted. |
|
For N<0, size(Input)-|N| characters are extracted. |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T> |
|
inline OutputIteratorT replace_head_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
int N, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::head_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace head algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline SequenceT replace_head_copy( |
|
const SequenceT& Input, |
|
int N, |
|
const RangeT& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::head_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace head algorithm |
|
/*! |
|
Replace the head of the input with the given format string. |
|
The head is a prefix of a string of given size. |
|
If the sequence is shorter then required, the whole string is |
|
considered to be the head. The input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param N Length of the head. |
|
For N>=0, at most N characters are extracted. |
|
For N<0, size(Input)-|N| characters are extracted. |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline void replace_head( |
|
SequenceT& Input, |
|
int N, |
|
const RangeT& Format ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::head_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
// replace_tail --------------------------------------------------------------------// |
|
|
|
//! Replace tail algorithm |
|
/*! |
|
Replace the tail of the input with the given format string. |
|
The tail is a suffix of a string of given size. |
|
If the sequence is shorter then required, whole string is |
|
considered to be the tail. |
|
The result is a modified copy of the input. It is returned as a sequence |
|
or copied to the output iterator. |
|
|
|
\param Output An output iterator to which the result will be copied |
|
\param Input An input string |
|
\param N Length of the tail. |
|
For N>=0, at most N characters are extracted. |
|
For N<0, size(Input)-|N| characters are extracted. |
|
\param Format A substitute string |
|
\return An output iterator pointing just after the last inserted character or |
|
a modified copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template< |
|
typename OutputIteratorT, |
|
typename Range1T, |
|
typename Range2T> |
|
inline OutputIteratorT replace_tail_copy( |
|
OutputIteratorT Output, |
|
const Range1T& Input, |
|
int N, |
|
const Range2T& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Output, |
|
Input, |
|
::boost::algorithm::tail_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace tail algorithm |
|
/*! |
|
\overload |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline SequenceT replace_tail_copy( |
|
const SequenceT& Input, |
|
int N, |
|
const RangeT& Format ) |
|
{ |
|
return ::boost::algorithm::find_format_copy( |
|
Input, |
|
::boost::algorithm::tail_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
//! Replace tail algorithm |
|
/*! |
|
Replace the tail of the input with the given format sequence. |
|
The tail is a suffix of a string of given size. |
|
If the sequence is shorter then required, the whole string is |
|
considered to be the tail. The input sequence is modified in-place. |
|
|
|
\param Input An input string |
|
\param N Length of the tail. |
|
For N>=0, at most N characters are extracted. |
|
For N<0, size(Input)-|N| characters are extracted. |
|
\param Format A substitute string |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline void replace_tail( |
|
SequenceT& Input, |
|
int N, |
|
const RangeT& Format ) |
|
{ |
|
::boost::algorithm::find_format( |
|
Input, |
|
::boost::algorithm::tail_finder(N), |
|
::boost::algorithm::const_formatter(Format) ); |
|
} |
|
|
|
} // namespace algorithm |
|
|
|
// pull names to the boost namespace |
|
using algorithm::replace_range_copy; |
|
using algorithm::replace_range; |
|
using algorithm::replace_first_copy; |
|
using algorithm::replace_first; |
|
using algorithm::ireplace_first_copy; |
|
using algorithm::ireplace_first; |
|
using algorithm::replace_last_copy; |
|
using algorithm::replace_last; |
|
using algorithm::ireplace_last_copy; |
|
using algorithm::ireplace_last; |
|
using algorithm::replace_nth_copy; |
|
using algorithm::replace_nth; |
|
using algorithm::ireplace_nth_copy; |
|
using algorithm::ireplace_nth; |
|
using algorithm::replace_all_copy; |
|
using algorithm::replace_all; |
|
using algorithm::ireplace_all_copy; |
|
using algorithm::ireplace_all; |
|
using algorithm::replace_head_copy; |
|
using algorithm::replace_head; |
|
using algorithm::replace_tail_copy; |
|
using algorithm::replace_tail; |
|
|
|
} // namespace boost |
|
|
|
#endif // BOOST_REPLACE_HPP
|
|
|