| // Boost string_algo library regex.hpp header file ---------------------------// | |
| // Copyright Pavol Droba 2002-2003. | |
| // | |
| // 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_REGEX_HPP | |
| #define BOOST_STRING_REGEX_HPP | |
| #include <boost/algorithm/string/config.hpp> | |
| #include <boost/regex.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/as_literal.hpp> | |
| #include <boost/algorithm/string/find_format.hpp> | |
| #include <boost/algorithm/string/regex_find_format.hpp> | |
| #include <boost/algorithm/string/formatter.hpp> | |
| #include <boost/algorithm/string/iter_find.hpp> | |
| /*! \file | |
| Defines regex variants of the algorithms. | |
| */ | |
| namespace boost { | |
| namespace algorithm { | |
| // find_regex -----------------------------------------------// | |
| //! Find regex algorithm | |
| /*! | |
| Search for a substring matching the given regex in the input. | |
| \param Input A container which will be searched. | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| \return | |
| An \c iterator_range delimiting the match. | |
| Returned iterator is either \c RangeT::iterator or | |
| \c RangeT::const_iterator, depending on the constness of | |
| the input parameter. | |
| \note This function provides the strong exception-safety guarantee | |
| */ | |
| template< | |
| typename RangeT, | |
| typename CharT, | |
| typename RegexTraitsT> | |
| inline iterator_range< | |
| BOOST_STRING_TYPENAME range_iterator<RangeT>::type > | |
| find_regex( | |
| RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); | |
| return ::boost::algorithm::regex_finder(Rx,Flags)( | |
| ::boost::begin(lit_input), ::boost::end(lit_input) ); | |
| } | |
| // replace_regex --------------------------------------------------------------------// | |
| //! Replace regex algorithm | |
| /*! | |
| Search for a substring matching given regex and format it with | |
| the specified format. | |
| 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 Rx A regular expression | |
| \param Format Regex format definition | |
| \param Flags Regex options | |
| \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 RangeT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline OutputIteratorT replace_regex_copy( | |
| OutputIteratorT Output, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| return ::boost::algorithm::find_format_copy( | |
| Output, | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| //! Replace regex algorithm | |
| /*! | |
| \overload | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline SequenceT replace_regex_copy( | |
| const SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| return ::boost::algorithm::find_format_copy( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| //! Replace regex algorithm | |
| /*! | |
| Search for a substring matching given regex and format it with | |
| the specified format. The input string is modified in-place. | |
| \param Input An input string | |
| \param Rx A regular expression | |
| \param Format Regex format definition | |
| \param Flags Regex options | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline void replace_regex( | |
| SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| ::boost::algorithm::find_format( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| // replace_all_regex --------------------------------------------------------------------// | |
| //! Replace all regex algorithm | |
| /*! | |
| Format all substrings, matching given regex, with the specified format. | |
| 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 Rx A regular expression | |
| \param Format Regex format definition | |
| \param Flags Regex options | |
| \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 RangeT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline OutputIteratorT replace_all_regex_copy( | |
| OutputIteratorT Output, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| return ::boost::algorithm::find_format_all_copy( | |
| Output, | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| //! Replace all regex algorithm | |
| /*! | |
| \overload | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline SequenceT replace_all_regex_copy( | |
| const SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| return ::boost::algorithm::find_format_all_copy( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| //! Replace all regex algorithm | |
| /*! | |
| Format all substrings, matching given regex, with the specified format. | |
| The input string is modified in-place. | |
| \param Input An input string | |
| \param Rx A regular expression | |
| \param Format Regex format definition | |
| \param Flags Regex options | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT, | |
| typename FormatStringTraitsT, typename FormatStringAllocatorT > | |
| inline void replace_all_regex( | |
| SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, | |
| match_flag_type Flags=match_default | format_default ) | |
| { | |
| ::boost::algorithm::find_format_all( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::regex_formatter( Format, Flags ) ); | |
| } | |
| // erase_regex --------------------------------------------------------------------// | |
| //! Erase regex algorithm | |
| /*! | |
| Remove a substring matching given regex from the input. | |
| 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 Rx A regular expression | |
| \param Flags Regex options | |
| \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 RangeT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline OutputIteratorT erase_regex_copy( | |
| OutputIteratorT Output, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::find_format_copy( | |
| Output, | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| //! Erase regex algorithm | |
| /*! | |
| \overload | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline SequenceT erase_regex_copy( | |
| const SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::find_format_copy( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| //! Erase regex algorithm | |
| /*! | |
| Remove a substring matching given regex from the input. | |
| The input string is modified in-place. | |
| \param Input An input string | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline void erase_regex( | |
| SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| ::boost::algorithm::find_format( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| // erase_all_regex --------------------------------------------------------------------// | |
| //! Erase all regex algorithm | |
| /*! | |
| Erase all substrings, matching given regex, from the input. | |
| 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 Rx A regular expression | |
| \param Flags Regex options | |
| \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 RangeT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline OutputIteratorT erase_all_regex_copy( | |
| OutputIteratorT Output, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::find_format_all_copy( | |
| Output, | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| //! Erase all regex algorithm | |
| /*! | |
| \overload | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline SequenceT erase_all_regex_copy( | |
| const SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::find_format_all_copy( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| //! Erase all regex algorithm | |
| /*! | |
| Erase all substrings, matching given regex, from the input. | |
| The input string is modified in-place. | |
| \param Input An input string | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| */ | |
| template< | |
| typename SequenceT, | |
| typename CharT, | |
| typename RegexTraitsT> | |
| inline void erase_all_regex( | |
| SequenceT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| ::boost::algorithm::find_format_all( | |
| Input, | |
| ::boost::algorithm::regex_finder( Rx, Flags ), | |
| ::boost::algorithm::empty_formatter( Input ) ); | |
| } | |
| // find_all_regex ------------------------------------------------------------------// | |
| //! Find all regex algorithm | |
| /*! | |
| This algorithm finds all substrings matching the give regex | |
| in the input. | |
| Each part is copied and added as a new element to the output container. | |
| Thus the result container must be able to hold copies | |
| of the matches (in a compatible structure like std::string) or | |
| a reference to it (e.g. using the iterator range class). | |
| Examples of such a container are \c std::vector<std::string> | |
| or \c std::list<boost::iterator_range<std::string::iterator>> | |
| \param Result A container that can hold copies of references to the substrings. | |
| \param Input A container which will be searched. | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| \return A reference to the result | |
| \note Prior content of the result will be overwritten. | |
| \note This function provides the strong exception-safety guarantee | |
| */ | |
| template< | |
| typename SequenceSequenceT, | |
| typename RangeT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline SequenceSequenceT& find_all_regex( | |
| SequenceSequenceT& Result, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::iter_find( | |
| Result, | |
| Input, | |
| ::boost::algorithm::regex_finder(Rx,Flags) ); | |
| } | |
| // split_regex ------------------------------------------------------------------// | |
| //! Split regex algorithm | |
| /*! | |
| Tokenize expression. This function is equivalent to C strtok. Input | |
| sequence is split into tokens, separated by separators. Separator | |
| is an every match of the given regex. | |
| Each part is copied and added as a new element to the output container. | |
| Thus the result container must be able to hold copies | |
| of the matches (in a compatible structure like std::string) or | |
| a reference to it (e.g. using the iterator range class). | |
| Examples of such a container are \c std::vector<std::string> | |
| or \c std::list<boost::iterator_range<std::string::iterator>> | |
| \param Result A container that can hold copies of references to the substrings. | |
| \param Input A container which will be searched. | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| \return A reference to the result | |
| \note Prior content of the result will be overwritten. | |
| \note This function provides the strong exception-safety guarantee | |
| */ | |
| template< | |
| typename SequenceSequenceT, | |
| typename RangeT, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline SequenceSequenceT& split_regex( | |
| SequenceSequenceT& Result, | |
| const RangeT& Input, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| return ::boost::algorithm::iter_split( | |
| Result, | |
| Input, | |
| ::boost::algorithm::regex_finder(Rx,Flags) ); | |
| } | |
| // join_if ------------------------------------------------------------------// | |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| //! Conditional join algorithm | |
| /*! | |
| This algorithm joins all strings in a 'list' into one long string. | |
| Segments are concatenated by given separator. Only segments that | |
| match the given regular expression will be added to the result | |
| This is a specialization of join_if algorithm. | |
| \param Input A container that holds the input strings. It must be a container-of-containers. | |
| \param Separator A string that will separate the joined segments. | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| \return Concatenated string. | |
| \note This function provides the strong exception-safety guarantee | |
| */ | |
| template< | |
| typename SequenceSequenceT, | |
| typename Range1T, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline typename range_value<SequenceSequenceT>::type | |
| join_if( | |
| const SequenceSequenceT& Input, | |
| const Range1T& Separator, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| // Define working types | |
| typedef typename range_value<SequenceSequenceT>::type ResultT; | |
| typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; | |
| // Parse input | |
| InputIteratorT itBegin=::boost::begin(Input); | |
| InputIteratorT itEnd=::boost::end(Input); | |
| // Construct container to hold the result | |
| ResultT Result; | |
| // Roll to the first element that will be added | |
| while( | |
| itBegin!=itEnd && | |
| !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin; | |
| // Add this element | |
| if(itBegin!=itEnd) | |
| { | |
| detail::insert(Result, ::boost::end(Result), *itBegin); | |
| ++itBegin; | |
| } | |
| for(;itBegin!=itEnd; ++itBegin) | |
| { | |
| if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) | |
| { | |
| // Add separator | |
| detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); | |
| // Add element | |
| detail::insert(Result, ::boost::end(Result), *itBegin); | |
| } | |
| } | |
| return Result; | |
| } | |
| #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| //! Conditional join algorithm | |
| /*! | |
| This algorithm joins all strings in a 'list' into one long string. | |
| Segments are concatenated by given separator. Only segments that | |
| match the given regular expression will be added to the result | |
| This is a specialization of join_if algorithm. | |
| \param Input A container that holds the input strings. It must be a container-of-containers. | |
| \param Separator A string that will separate the joined segments. | |
| \param Rx A regular expression | |
| \param Flags Regex options | |
| \return Concatenated string. | |
| \note This function provides the strong exception-safety guarantee | |
| */ | |
| template< | |
| typename SequenceSequenceT, | |
| typename Range1T, | |
| typename CharT, | |
| typename RegexTraitsT > | |
| inline typename range_value<SequenceSequenceT>::type | |
| join_if_regex( | |
| const SequenceSequenceT& Input, | |
| const Range1T& Separator, | |
| const basic_regex<CharT, RegexTraitsT>& Rx, | |
| match_flag_type Flags=match_default ) | |
| { | |
| // Define working types | |
| typedef typename range_value<SequenceSequenceT>::type ResultT; | |
| typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; | |
| // Parse input | |
| InputIteratorT itBegin=::boost::begin(Input); | |
| InputIteratorT itEnd=::boost::end(Input); | |
| // Construct container to hold the result | |
| ResultT Result; | |
| // Roll to the first element that will be added | |
| while( | |
| itBegin!=itEnd && | |
| !::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) ++itBegin; | |
| // Add this element | |
| if(itBegin!=itEnd) | |
| { | |
| detail::insert(Result, ::boost::end(Result), *itBegin); | |
| ++itBegin; | |
| } | |
| for(;itBegin!=itEnd; ++itBegin) | |
| { | |
| if(::boost::regex_match(::boost::begin(*itBegin), ::boost::end(*itBegin), Rx, Flags)) | |
| { | |
| // Add separator | |
| detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); | |
| // Add element | |
| detail::insert(Result, ::boost::end(Result), *itBegin); | |
| } | |
| } | |
| return Result; | |
| } | |
| #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| } // namespace algorithm | |
| // pull names into the boost namespace | |
| using algorithm::find_regex; | |
| using algorithm::replace_regex; | |
| using algorithm::replace_regex_copy; | |
| using algorithm::replace_all_regex; | |
| using algorithm::replace_all_regex_copy; | |
| using algorithm::erase_regex; | |
| using algorithm::erase_regex_copy; | |
| using algorithm::erase_all_regex; | |
| using algorithm::erase_all_regex_copy; | |
| using algorithm::find_all_regex; | |
| using algorithm::split_regex; | |
| #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| using algorithm::join_if; | |
| #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| using algorithm::join_if_regex; | |
| #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING | |
| } // namespace boost | |
| #endif // BOOST_STRING_REGEX_HPP |