boost/algorithm/string/regex.hpp
// Boost string_algo library regex.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. Use, modification and // distribution is subject to 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/algorithm/string/collection_traits.hpp> #include <boost/algorithm/string/iterator_range.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 InputContainerT::iterator or \c InputContainerT::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee */ template< typename CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT> inline iterator_range< BOOST_STRING_TYPENAME result_iterator_of<CollectionT>::type > find_regex( CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return regex_finder(Rx,Flags)( begin(Input), end(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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline OutputIteratorT replace_regex_copy( OutputIteratorT Output, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { return find_format_copy( Output, Input, regex_finder( Rx, Flags ), regex_formatter( Format, Flags ) ); } //! Replace regex algorithm /*! \overload */ template< typename SequenceT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline SequenceT replace_regex_copy( const SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { return find_format_copy( Input, regex_finder( Rx, Flags ), 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 RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline void replace_regex( SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { find_format( Input, regex_finder( Rx, Flags ), 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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline OutputIteratorT replace_all_regex_copy( OutputIteratorT Output, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { return find_format_all_copy( Output, Input, regex_finder( Rx, Flags ), regex_formatter( Format, Flags ) ); } //! Replace all regex algorithm /*! \overload */ template< typename SequenceT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline SequenceT replace_all_regex_copy( const SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { return find_format_all_copy( Input, regex_finder( Rx, Flags ), 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 RegexAllocatorT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline void replace_all_regex( SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default | format_default ) { find_format_all( Input, regex_finder( Rx, Flags ), 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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline OutputIteratorT erase_regex_copy( OutputIteratorT Output, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return find_format_copy( Output, Input, regex_finder( Rx, Flags ), empty_formatter( Input ) ); } //! Erase regex algorithm /*! \overload */ template< typename SequenceT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline SequenceT erase_regex_copy( const SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return find_format_copy( Input, regex_finder( Rx, Flags ), 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, typename RegexAllocatorT > inline void erase_regex( SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { find_format( Input, regex_finder( Rx, Flags ), 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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline OutputIteratorT erase_all_regex_copy( OutputIteratorT Output, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return find_format_all_copy( Output, Input, regex_finder( Rx, Flags ), empty_formatter( Input ) ); } //! Erase all regex algorithm /*! \overload */ template< typename SequenceT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline SequenceT erase_all_regex_copy( const SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return find_format_all_copy( Input, regex_finder( Rx, Flags ), 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, typename RegexAllocatorT> inline void erase_all_regex( SequenceT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { find_format_all( Input, regex_finder( Rx, Flags ), 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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline SequenceSequenceT& find_all_regex( SequenceSequenceT& Result, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return iter_find( Result, Input, 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 CollectionT, typename CharT, typename RegexTraitsT, typename RegexAllocatorT > inline SequenceSequenceT& split_regex( SequenceSequenceT& Result, const CollectionT& Input, const reg_expression<CharT, RegexTraitsT, RegexAllocatorT>& Rx, match_flag_type Flags=match_default ) { return iter_split( Result, Input, regex_finder(Rx,Flags) ); } } // 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; } // namespace boost #endif // BOOST_STRING_REGEX_HPP