/////////////////////////////////////////////////////////////////////////////// | |
/// \file regex_algorithms.hpp | |
/// Contains the regex_match(), regex_search() and regex_replace() algorithms. | |
// | |
// Copyright 2008 Eric Niebler. 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) | |
#ifndef BOOST_XPRESSIVE_ALGORITHMS_HPP_EAN_10_04_2005 | |
#define BOOST_XPRESSIVE_ALGORITHMS_HPP_EAN_10_04_2005 | |
// MS compatible compilers support #pragma once | |
#if defined(_MSC_VER) && (_MSC_VER >= 1020) | |
# pragma once | |
#endif | |
#include <string> | |
#include <iterator> | |
#include <boost/mpl/or.hpp> | |
#include <boost/range/end.hpp> | |
#include <boost/range/begin.hpp> | |
#include <boost/mpl/identity.hpp> | |
#include <boost/utility/enable_if.hpp> | |
#include <boost/type_traits/add_const.hpp> | |
#include <boost/type_traits/is_pointer.hpp> | |
#include <boost/type_traits/remove_const.hpp> | |
#include <boost/xpressive/match_results.hpp> | |
#include <boost/xpressive/detail/detail_fwd.hpp> | |
#include <boost/xpressive/detail/core/state.hpp> | |
#include <boost/xpressive/detail/utility/save_restore.hpp> | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_XPR_NONDEDUCED_TYPE_(x) typename mpl::identity<x>::type | |
namespace boost { namespace xpressive | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_match | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace detail | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_match_impl | |
template<typename BidiIter> | |
inline bool regex_match_impl | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
BOOST_ASSERT(0 != re.regex_id()); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
state.flags_.match_all_ = true; | |
state.sub_match(0).begin_ = begin; | |
if(access::match(re, state)) | |
{ | |
access::set_prefix_suffix(what, begin, end); | |
return true; | |
} | |
// handle partial matches | |
else if(state.found_partial_match_ && 0 != (flags & regex_constants::match_partial)) | |
{ | |
state.set_partial_match(); | |
return true; | |
} | |
access::reset(what); | |
return false; | |
} | |
} // namespace detail | |
/// \brief See if a regex matches a sequence from beginning to end. | |
/// | |
/// Determines whether there is an exact match between the regular expression \c re, | |
/// and all of the sequence <tt>[begin, end)</tt>. | |
/// | |
/// \pre Type \c BidiIter meets the requirements of a Bidirectional Iterator (24.1.4). | |
/// \pre <tt>[begin,end)</tt> denotes a valid iterator range. | |
/// \param begin The beginning of the sequence. | |
/// \param end The end of the sequence. | |
/// \param what The \c match_results struct into which the sub_matches will be written | |
/// \param re The regular expression object to use | |
/// \param flags Optional match flags, used to control how the expression is matched | |
/// against the sequence. (See \c match_flag_type.) | |
/// \return \c true if a match is found, \c false otherwise | |
/// \throw regex_error on stack exhaustion | |
template<typename BidiIter> | |
inline bool regex_match | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiIter> | |
inline bool regex_match | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename Char> | |
inline bool regex_match | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *begin | |
, match_results<Char *> &what | |
, basic_regex<Char *> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<Char *> access; | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// BUGBUG this is inefficient | |
typedef typename remove_const<Char>::type char_type; | |
Char *end = begin + std::char_traits<char_type>::length(begin); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_match | |
( | |
BidiRange &rng | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_match | |
( | |
BidiRange const &rng | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename Char> | |
inline bool regex_match | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *begin | |
, basic_regex<Char *> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<Char *> what; | |
typedef typename remove_const<Char>::type char_type; | |
Char *end = begin + std::char_traits<char_type>::length(begin); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_match | |
( | |
BidiRange &rng | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_match | |
( | |
BidiRange const &rng | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
return detail::regex_match_impl(begin, end, what, re, flags); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_search | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace detail | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_search_impl | |
template<typename BidiIter> | |
inline bool regex_search_impl | |
( | |
match_state<BidiIter> &state | |
, basic_regex<BidiIter> const &re | |
, bool not_initial_null = false | |
) | |
{ | |
typedef core_access<BidiIter> access; | |
typedef typename iterator_value<BidiIter>::type char_type; | |
match_results<BidiIter> &what = *state.context_.results_ptr_; | |
BOOST_ASSERT(0 != re.regex_id()); | |
bool const partial_ok = state.flags_.match_partial_; | |
save_restore<bool> not_null(state.flags_.match_not_null_, state.flags_.match_not_null_ || not_initial_null); | |
state.flags_.match_prev_avail_ = state.flags_.match_prev_avail_ || !state.bos(); | |
regex_impl<BidiIter> const &impl = *access::get_regex_impl(re); | |
BidiIter const begin = state.cur_, end = state.end_; | |
BidiIter &sub0begin = state.sub_match(0).begin_; | |
sub0begin = state.cur_; | |
// If match_continuous is set, we only need to check for a match at the current position | |
if(state.flags_.match_continuous_) | |
{ | |
if(access::match(re, state)) | |
{ | |
access::set_prefix_suffix(what, begin, end); | |
return true; | |
} | |
// handle partial matches | |
else if(partial_ok && state.found_partial_match_) | |
{ | |
state.set_partial_match(); | |
return true; | |
} | |
} | |
// If we have a finder, use it to find where a potential match can start | |
else if(impl.finder_ && (!partial_ok || impl.finder_->ok_for_partial_matches())) | |
{ | |
finder<BidiIter> const &find = *impl.finder_; | |
if(find(state)) | |
{ | |
if(state.cur_ != begin) | |
{ | |
not_null.restore(); | |
} | |
do | |
{ | |
sub0begin = state.cur_; | |
if(access::match(re, state)) | |
{ | |
access::set_prefix_suffix(what, begin, end); | |
return true; | |
} | |
// handle partial matches | |
else if(partial_ok && state.found_partial_match_) | |
{ | |
state.set_partial_match(); | |
return true; | |
} | |
BOOST_ASSERT(state.cur_ == sub0begin); | |
not_null.restore(); | |
} | |
while(state.cur_ != state.end_ && (++state.cur_, find(state))); | |
} | |
} | |
// Otherwise, use brute force search at every position. | |
else | |
{ | |
for(;;) | |
{ | |
if(access::match(re, state)) | |
{ | |
access::set_prefix_suffix(what, begin, end); | |
return true; | |
} | |
// handle partial matches | |
else if(partial_ok && state.found_partial_match_) | |
{ | |
state.set_partial_match(); | |
return true; | |
} | |
else if(end == sub0begin) | |
{ | |
break; | |
} | |
BOOST_ASSERT(state.cur_ == sub0begin); | |
state.cur_ = ++sub0begin; | |
not_null.restore(); | |
} | |
} | |
access::reset(what); | |
return false; | |
} | |
} // namespace detail | |
/// \brief Determines whether there is some sub-sequence within <tt>[begin,end)</tt> | |
/// that matches the regular expression \c re. | |
/// | |
/// Determines whether there is some sub-sequence within <tt>[begin,end)</tt> that matches | |
/// the regular expression \c re. | |
/// | |
/// \pre Type \c BidiIter meets the requirements of a Bidirectional Iterator (24.1.4). | |
/// \pre <tt>[begin,end)</tt> denotes a valid iterator range. | |
/// \param begin The beginning of the sequence | |
/// \param end The end of the sequence | |
/// \param what The \c match_results struct into which the sub_matches will be written | |
/// \param re The regular expression object to use | |
/// \param flags Optional match flags, used to control how the expression is matched against | |
/// the sequence. (See \c match_flag_type.) | |
/// \return \c true if a match is found, \c false otherwise | |
/// \throw regex_error on stack exhaustion | |
template<typename BidiIter> | |
inline bool regex_search | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename BidiIter> | |
inline bool regex_search | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename Char> | |
inline bool regex_search | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *begin | |
, match_results<Char *> &what | |
, basic_regex<Char *> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<Char *> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// BUGBUG this is inefficient | |
typedef typename remove_const<Char>::type char_type; | |
Char *end = begin + std::char_traits<char_type>::length(begin); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<Char *> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_search | |
( | |
BidiRange &rng | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_search | |
( | |
BidiRange const &rng | |
, match_results<BidiIter> &what | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
access::reset(what); | |
return false; | |
} | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename Char> | |
inline bool regex_search | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *begin | |
, basic_regex<Char *> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef detail::core_access<Char *> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<Char *> what; | |
// BUGBUG this is inefficient | |
typedef typename remove_const<Char>::type char_type; | |
Char *end = begin + std::char_traits<char_type>::length(begin); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<Char *> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_search | |
( | |
BidiRange &rng | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/// \overload | |
/// | |
template<typename BidiRange, typename BidiIter> | |
inline bool regex_search | |
( | |
BidiRange const &rng | |
, basic_regex<BidiIter> const &re | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiRange> >::type * = 0 | |
) | |
{ | |
typedef detail::core_access<BidiIter> access; | |
// a default-constructed regex matches nothing | |
if(0 == re.regex_id()) | |
{ | |
return false; | |
} | |
// BUGBUG this is inefficient | |
match_results<BidiIter> what; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(rng), end = boost::end(rng); | |
// the state object holds matching state and | |
// is passed by reference to all the matchers | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
return detail::regex_search_impl(state, re); | |
} | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_replace | |
/////////////////////////////////////////////////////////////////////////////// | |
namespace detail | |
{ | |
/////////////////////////////////////////////////////////////////////////////// | |
// regex_replace_impl | |
template<typename OutIter, typename BidiIter, typename Formatter> | |
inline OutIter regex_replace_impl | |
( | |
OutIter out | |
, BidiIter begin | |
, BidiIter end | |
, basic_regex<BidiIter> const &re | |
, Formatter const &format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
using namespace regex_constants; | |
typedef detail::core_access<BidiIter> access; | |
BOOST_ASSERT(0 != re.regex_id()); | |
BidiIter cur = begin; | |
match_results<BidiIter> what; | |
detail::match_state<BidiIter> state(begin, end, what, *access::get_regex_impl(re), flags); | |
bool const yes_copy = (0 == (flags & format_no_copy)); | |
if(detail::regex_search_impl(state, re)) | |
{ | |
if(yes_copy) | |
{ | |
out = std::copy(cur, what[0].first, out); | |
} | |
out = what.format(out, format, flags); | |
cur = state.cur_ = state.next_search_ = what[0].second; | |
if(0 == (flags & format_first_only)) | |
{ | |
bool not_null = (0 == what.length()); | |
state.reset(what, *access::get_regex_impl(re)); | |
while(detail::regex_search_impl(state, re, not_null)) | |
{ | |
if(yes_copy) | |
{ | |
out = std::copy(cur, what[0].first, out); | |
} | |
access::set_prefix_suffix(what, begin, end); | |
out = what.format(out, format, flags); | |
cur = state.cur_ = state.next_search_ = what[0].second; | |
not_null = (0 == what.length()); | |
state.reset(what, *access::get_regex_impl(re)); | |
} | |
} | |
} | |
if(yes_copy) | |
{ | |
out = std::copy(cur, end, out); | |
} | |
return out; | |
} | |
} // namespace detail | |
/// \brief Build an output sequence given an input sequence, a regex, and a format string or | |
/// a formatter object, function, or expression. | |
/// | |
/// Constructs a \c regex_iterator object: <tt>regex_iterator\< BidiIter \> i(begin, end, re, flags)</tt>, | |
/// and uses \c i to enumerate through all of the matches m of type <tt>match_results\< BidiIter \></tt> that | |
/// occur within the sequence <tt>[begin, end)</tt>. If no such matches are found and <tt>!(flags \& format_no_copy)</tt> | |
/// then calls <tt>std::copy(begin, end, out)</tt>. Otherwise, for each match found, if <tt>!(flags \& format_no_copy)</tt> | |
/// calls <tt>std::copy(m.prefix().first, m.prefix().second, out)</tt>, and then calls <tt>m.format(out, format, flags)</tt>. | |
/// Finally if <tt>!(flags \& format_no_copy)</tt> calls <tt>std::copy(last_m.suffix().first, last_m.suffix().second, out)</tt> | |
/// where \c last_m is a copy of the last match found. | |
/// | |
/// If <tt>flags \& format_first_only</tt> is non-zero then only the first match found is replaced. | |
/// | |
/// \pre Type \c BidiIter meets the requirements of a Bidirectional Iterator (24.1.4). | |
/// \pre Type \c OutIter meets the requirements of an Output Iterator (24.1.2). | |
/// \pre Type \c Formatter models \c ForwardRange, <tt>Callable\<match_results\<BidiIter\> \></tt>, | |
/// <tt>Callable\<match_results\<BidiIter\>, OutIter\></tt>, or | |
/// <tt>Callable\<match_results\<BidiIter\>, OutIter, regex_constants::match_flag_type\></tt>; | |
/// or else it is a null-terminated format string, or an expression template | |
/// representing a formatter lambda expression. | |
/// \pre <tt>[begin,end)</tt> denotes a valid iterator range. | |
/// \param out An output iterator into which the output sequence is written. | |
/// \param begin The beginning of the input sequence. | |
/// \param end The end of the input sequence. | |
/// \param re The regular expression object to use. | |
/// \param format The format string used to format the replacement sequence, | |
/// or a formatter function, function object, or expression. | |
/// \param flags Optional match flags, used to control how the expression is matched against | |
/// the sequence. (See \c match_flag_type.) | |
/// \return The value of the output iterator after the output sequence has been written to it. | |
/// \throw regex_error on stack exhaustion or invalid format string. | |
template<typename OutIter, typename BidiIter, typename Formatter> | |
inline OutIter regex_replace | |
( | |
OutIter out | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, basic_regex<BidiIter> const &re | |
, Formatter const &format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<Formatter> >::type * = 0 | |
) | |
{ | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
out = std::copy(begin, end, out); | |
} | |
return out; | |
} | |
return detail::regex_replace_impl(out, begin, end, re, format, flags); | |
} | |
/// \overload | |
/// | |
template<typename OutIter, typename BidiIter> | |
inline OutIter regex_replace | |
( | |
OutIter out | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) begin | |
, BOOST_XPR_NONDEDUCED_TYPE_(BidiIter) end | |
, basic_regex<BidiIter> const &re | |
, typename iterator_value<BidiIter>::type const *format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
out = std::copy(begin, end, out); | |
} | |
return out; | |
} | |
return detail::regex_replace_impl(out, begin, end, re, format, flags); | |
} | |
/// \overload | |
/// | |
template<typename BidiContainer, typename BidiIter, typename Formatter> | |
inline BidiContainer regex_replace | |
( | |
BidiContainer &str | |
, basic_regex<BidiIter> const &re | |
, Formatter const &format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<mpl::or_<detail::is_char_ptr<BidiContainer>, detail::is_char_ptr<Formatter> > >::type * = 0 | |
) | |
{ | |
BidiContainer result; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(str), end = boost::end(str); | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
std::copy(begin, end, std::back_inserter(result)); | |
} | |
return result; | |
} | |
detail::regex_replace_impl(std::back_inserter(result), begin, end, re, format, flags); | |
return result; | |
} | |
/// \overload | |
/// | |
template<typename BidiContainer, typename BidiIter, typename Formatter> | |
inline BidiContainer regex_replace | |
( | |
BidiContainer const &str | |
, basic_regex<BidiIter> const &re | |
, Formatter const &format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<mpl::or_<detail::is_char_ptr<BidiContainer>, detail::is_char_ptr<Formatter> > >::type * = 0 | |
) | |
{ | |
BidiContainer result; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(str), end = boost::end(str); | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
std::copy(begin, end, std::back_inserter(result)); | |
} | |
return result; | |
} | |
detail::regex_replace_impl(std::back_inserter(result), begin, end, re, format, flags); | |
return result; | |
} | |
/// \overload | |
/// | |
template<typename Char, typename Formatter> | |
inline std::basic_string<typename remove_const<Char>::type> regex_replace | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *str | |
, basic_regex<Char *> const &re | |
, Formatter const &format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<Formatter> >::type * = 0 | |
) | |
{ | |
typedef typename remove_const<Char>::type char_type; | |
std::basic_string<char_type> result; | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
result = str; | |
} | |
return result; | |
} | |
Char *end = str + std::char_traits<char_type>::length(str); | |
detail::regex_replace_impl(std::back_inserter(result), str, end, re, format, flags); | |
return result; | |
} | |
/// \overload | |
/// | |
template<typename BidiContainer, typename BidiIter> | |
inline BidiContainer regex_replace | |
( | |
BidiContainer &str | |
, basic_regex<BidiIter> const &re | |
, typename iterator_value<BidiIter>::type const *format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiContainer> >::type * = 0 | |
) | |
{ | |
BidiContainer result; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(str), end = boost::end(str); | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
std::copy(begin, end, std::back_inserter(result)); | |
} | |
return result; | |
} | |
detail::regex_replace_impl(std::back_inserter(result), begin, end, re, format, flags); | |
return result; | |
} | |
/// \overload | |
/// | |
template<typename BidiContainer, typename BidiIter> | |
inline BidiContainer regex_replace | |
( | |
BidiContainer const &str | |
, basic_regex<BidiIter> const &re | |
, typename iterator_value<BidiIter>::type const *format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
, typename disable_if<detail::is_char_ptr<BidiContainer> >::type * = 0 | |
) | |
{ | |
BidiContainer result; | |
// Note that the result iterator of the range must be convertible | |
// to BidiIter here. | |
BidiIter begin = boost::begin(str), end = boost::end(str); | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
std::copy(begin, end, std::back_inserter(result)); | |
} | |
return result; | |
} | |
detail::regex_replace_impl(std::back_inserter(result), begin, end, re, format, flags); | |
return result; | |
} | |
/// \overload | |
/// | |
template<typename Char> | |
inline std::basic_string<typename remove_const<Char>::type> regex_replace | |
( | |
BOOST_XPR_NONDEDUCED_TYPE_(Char) *str | |
, basic_regex<Char *> const &re | |
, typename add_const<Char>::type *format | |
, regex_constants::match_flag_type flags = regex_constants::match_default | |
) | |
{ | |
typedef typename remove_const<Char>::type char_type; | |
std::basic_string<char_type> result; | |
// Default-constructed regexes match nothing | |
if(0 == re.regex_id()) | |
{ | |
if((0 == (flags & regex_constants::format_no_copy))) | |
{ | |
result = str; | |
} | |
return result; | |
} | |
Char *end = str + std::char_traits<char_type>::length(str); | |
detail::regex_replace_impl(std::back_inserter(result), str, end, re, format, flags); | |
return result; | |
} | |
}} // namespace boost::xpressive | |
#endif |