boost/xpressive/match_results.hpp
/////////////////////////////////////////////////////////////////////////////// /// \file match_results.hpp /// Contains the definition of the match_results type and associated helpers. /// The match_results type holds the results of a regex_match() or /// regex_search() operation. // // Copyright 2004 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_MATCH_RESULTS_HPP_EAN_10_04_2005 #define BOOST_XPRESSIVE_MATCH_RESULTS_HPP_EAN_10_04_2005 // MS compatible compilers support #pragma once #if defined(_MSC_VER) && (_MSC_VER >= 1020) # pragma once #endif #include <iterator> #include <boost/assert.hpp> #include <boost/shared_ptr.hpp> #include <boost/iterator_adaptors.hpp> #if BOOST_ITERATOR_ADAPTORS_VERSION >= 0x0200 # include <boost/iterator/filter_iterator.hpp> #endif #include <boost/xpressive/regex_constants.hpp> #include <boost/xpressive/detail/detail_fwd.hpp> #include <boost/xpressive/detail/core/sub_match_vector.hpp> #include <boost/xpressive/detail/utility/sequence_stack.hpp> #include <boost/xpressive/detail/core/results_cache.hpp> #include <boost/xpressive/detail/core/action_state.hpp> #include <boost/xpressive/detail/utility/literals.hpp> #include <boost/xpressive/detail/utility/algorithm.hpp> namespace boost { namespace xpressive { namespace detail { /////////////////////////////////////////////////////////////////////////////// // results_extras // template<typename BidiIter> struct results_extras { sequence_stack<sub_match_impl<BidiIter> > sub_match_stack_; results_cache<BidiIter> results_cache_; }; /////////////////////////////////////////////////////////////////////////////// // results_traits // template<typename Char> struct results_traits { static int value(Char ch, int radix = 10) { BOOST_ASSERT(10 == radix); if(ch >= BOOST_XPR_CHAR_(Char, '0') && ch <= BOOST_XPR_CHAR_(Char, '9')) { return ch - BOOST_XPR_CHAR_(Char, '0'); } return -1; } }; } // namespace detail /////////////////////////////////////////////////////////////////////////////// // match_results /// \brief Class template match_results\<\> holds the results of a regex_match() or a /// regex_search() as a collection of sub_match objects. /// /// Class template match_results\<\> denotes a collection of sequences representing the result of /// a regular expression match. Storage for the collection is allocated and freed as necessary by /// the member functions of class match_results\<\>. /// /// The class template match_results\<\> conforms to the requirements of a Sequence, as specified /// in (lib.sequence.reqmts), except that only operations defined for const-qualified Sequences are /// supported. template<typename BidiIter> struct match_results { private: struct dummy { int i_; }; typedef int dummy::*bool_type; public: typedef typename iterator_value<BidiIter>::type char_type; typedef std::basic_string<char_type> string_type; typedef std::size_t size_type; typedef sub_match<BidiIter> value_type; typedef typename iterator_difference<BidiIter>::type difference_type; typedef value_type const &reference; typedef value_type const &const_reference; typedef typename detail::sub_match_vector<BidiIter>::iterator iterator; typedef typename detail::sub_match_vector<BidiIter>::const_iterator const_iterator; typedef typename detail::nested_results<BidiIter> nested_results_type; /// \post regex_id() == 0 /// \post size() == 0 /// \post empty() == true match_results() : regex_id_(0) , sub_matches_() , base_() , prefix_() , suffix_() , nested_results_() , action_state_() , extras_ptr_() { } /// \param that The match_results object to copy /// \post regex_id() == that.regex_id(). /// \post size() == that.size(). /// \post empty() == that.empty(). /// \post str(n) == that.str(n) for all positive integers n \< that.size(). /// \post prefix() == that.prefix(). /// \post suffix() == that.suffix(). /// \post (*this)[n] == that[n] for all positive integers n \< that.size(). /// \post length(n) == that.length(n) for all positive integers n \< that.size(). /// \post position(n) == that.position(n) for all positive integers n \< that.size(). match_results(match_results<BidiIter> const &that) : regex_id_(that.regex_id_) , sub_matches_() , base_() , prefix_() , suffix_() , nested_results_() , action_state_(that.action_state_) , extras_ptr_() { if(that) { extras_type &extras = this->get_extras_(); std::size_t size = that.sub_matches_.size(); detail::sub_match_impl<BidiIter> *sub_matches = extras.sub_match_stack_.push_sequence(size); detail::core_access<BidiIter>::init_sub_match_vector(this->sub_matches_, sub_matches, size, that.sub_matches_); // BUGBUG this doesn't share the extras::sequence_stack this->nested_results_ = that.nested_results_; this->prefix_ = that.prefix_; this->suffix_ = that.suffix_; this->base_ = that.base_; } } ~match_results() { } /// \param that The match_results object to copy. /// \post regex_id() == that.regex_id(). /// \post size() == that.size(). /// \post empty() == that.empty(). /// \post str(n) == that.str(n) for all positive integers n \< that.size(). /// \post prefix() == that.prefix(). /// \post suffix() == that.suffix(). /// \post (*this)[n] == that[n] for all positive integers n \< that.size(). /// \post length(n) == that.length(n) for all positive integers n \< that.size(). /// \post position(n) == that.position(n) for all positive integers n \< that.size(). match_results<BidiIter> &operator =(match_results<BidiIter> const &that) { match_results<BidiIter>(that).swap(*this); return *this; } /// Returns the number of sub_match elements stored in *this. /// size_type size() const { return this->sub_matches_.size(); } /// Returns size() == 0. /// bool empty() const { return 0 == this->size(); } /// Returns (*this)[sub].length(). /// difference_type length(size_type sub = 0) const { return (*this)[ sub ].length(); } /// If !(*this)[sub].matched then returns -1. Otherwise returns std::distance(base, (*this)[sub].first), /// where base is the start iterator of the sequence that was searched. [Note � unless this is part /// of a repeated search with a regex_iterator then base is the same as prefix().first � end note] difference_type position(size_type sub = 0) const { return (*this)[ sub ].matched ? std::distance(this->base_, (*this)[ sub ].first) : -1; } /// Returns string_type((*this)[sub]). /// string_type str(size_type sub = 0) const { return (*this)[ sub ].str(); } /// Returns a reference to the sub_match object representing the sequence that /// matched marked sub-expression sub. If sub == 0 then returns a reference to a sub_match object /// representing the sequence that matched the whole regular expression. /// \pre sub \< (*this).size(). const_reference operator [](size_type sub) const { return this->sub_matches_[ sub ]; } /// \overload /// const_reference operator [](detail::mark_tag const &mark) const { return this->sub_matches_[ detail::get_mark_number(mark) ]; } /// Returns a reference to the sub_match object representing the character sequence from /// the start of the string being matched/searched, to the start of the match found. /// const_reference prefix() const { return this->prefix_; } /// Returns a reference to the sub_match object representing the character sequence from /// the end of the match found to the end of the string being matched/searched. /// const_reference suffix() const { return this->suffix_; } /// Returns a starting iterator that enumerates over all the marked sub-expression matches /// stored in *this. /// const_iterator begin() const { return this->sub_matches_.begin(); } /// Returns a terminating iterator that enumerates over all the marked sub-expression /// matches stored in *this. /// const_iterator end() const { return this->sub_matches_.end(); } /// Returns a true value if(*this)[0].matched, else returns a false value. /// operator bool_type() const { return (*this)[ 0 ].matched ? &dummy::i_ : 0; } /// Returns true if empty() || !(*this)[0].matched, else returns false. /// bool operator !() const { return this->empty() || !(*this)[ 0 ].matched; } /// Returns the id of the basic_regex object most recently used with this match_results object. /// regex_id_type regex_id() const { return this->regex_id_; } /// Returns a Sequence of nested match_results elements. /// nested_results_type const &nested_results() const { return this->nested_results_; } /// Copies the character sequence [fmt.begin(), fmt.end()) to OutputIterator out. For each format /// specifier or escape sequence in fmt, replace that sequence with either the character(s) it /// represents, or the sequence within *this to which it refers. The bitmasks specified in flags /// determines what format specifiers or escape sequences are recognized, by default this is the /// format used by ECMA-262, ECMAScript Language Specification, Chapter 15 part 5.4.11 String.prototype.replace. template<typename OutputIterator> OutputIterator format ( OutputIterator out , const string_type &fmt , regex_constants::match_flag_type flags = regex_constants::format_default ) const { detail::results_traits<char_type> traits; typename string_type::const_iterator cur = fmt.begin(), end = fmt.end(); if(0 != (regex_constants::format_literal & flags)) { out = std::copy(cur, end, out); } else while(cur != end) { if(BOOST_XPR_CHAR_(char_type, '$') != *cur) { *out++ = *cur++; } else if(++cur == end) { *out++ = BOOST_XPR_CHAR_(char_type, '$'); } else if(BOOST_XPR_CHAR_(char_type, '$') == *cur) { *out++ = *cur++; } else if(BOOST_XPR_CHAR_(char_type, '&') == *cur) // whole match { ++cur; out = std::copy((*this)[ 0 ].first, (*this)[ 0 ].second, out); } else if(BOOST_XPR_CHAR_(char_type, '`') == *cur) // prefix { ++cur; out = std::copy(this->prefix().first, this->prefix().second, out); } else if(BOOST_XPR_CHAR_(char_type, '\'') == *cur) // suffix { ++cur; out = std::copy(this->suffix().first, this->suffix().second, out); } else if(-1 != traits.value(*cur, 10)) // a sub-match { int max = static_cast<int>(this->size() - 1); int br_nbr = detail::toi(cur, end, traits, 10, max); detail::ensure(0 != br_nbr, regex_constants::error_subreg, "invalid back-reference"); out = std::copy((*this)[ br_nbr ].first, (*this)[ br_nbr ].second, out); } else { *out++ = BOOST_XPR_CHAR_(char_type, '$'); *out++ = *cur++; } } return out; } /// Returns a copy of the string fmt. For each format specifier or escape sequence in fmt, /// replace that sequence with either the character(s) it represents, or the sequence within /// *this to which it refers. The bitmasks specified in flags determines what format specifiers /// or escape sequences are recognized, by default this is the format used by ECMA-262, /// ECMAScript Language Specification, Chapter 15 part 5.4.11 String.prototype.replace. string_type format(const string_type &fmt, regex_constants::match_flag_type flags = regex_constants::format_default) const { string_type result; result.reserve(fmt.length() * 2); this->format(std::back_inserter(result), fmt, flags); return result; } /// Swaps the contents of two match_results objects. Guaranteed not to throw. /// \param that The match_results object to swap with. /// \post *this contains the sequence of matched sub-expressions that were in that, /// that contains the sequence of matched sub-expressions that were in *this. /// \throw nothrow void swap(match_results<BidiIter> &that) // throw() { std::swap(this->regex_id_, that.regex_id_); this->sub_matches_.swap(that.sub_matches_); std::swap(this->base_, that.base_); std::swap(this->prefix_, that.prefix_); std::swap(this->suffix_, that.suffix_); this->nested_results_.swap(that.nested_results_); std::swap(this->action_state_, that.action_state_); this->extras_ptr_.swap(that.extras_ptr_); } /// INTERNAL ONLY match_results<BidiIter> const &operator ()(regex_id_type regex_id, size_type index = 0) const { // BUGBUG this is linear, make it O(1) static match_results<BidiIter> const s_null; regex_id_filter_predicate<BidiIter> pred(regex_id); typename nested_results_type::const_iterator begin = this->nested_results_.begin() , end = this->nested_results_.end() , cur = detail::find_nth_if(begin, end, index, pred); return (cur == end) ? s_null : *cur; } /// INTERNAL ONLY match_results<BidiIter> const &operator ()(basic_regex<BidiIter> const &rex, std::size_t index = 0) const { return (*this)(rex.regex_id(), index); } // state: /// INTERNAL ONLY template<typename State> void set_action_state(State &state) { this->action_state_.set(state); } /// INTERNAL ONLY template<typename State> State &get_action_state() const { return this->action_state_.BOOST_NESTED_TEMPLATE get<State>(); } private: friend struct detail::core_access<BidiIter>; typedef detail::results_extras<BidiIter> extras_type; /// INTERNAL ONLY void init_ ( regex_id_type regex_id , detail::sub_match_impl<BidiIter> *sub_matches , size_type size ) { this->regex_id_ = regex_id; detail::core_access<BidiIter>::init_sub_match_vector(this->sub_matches_, sub_matches, size); } /// INTERNAL ONLY extras_type &get_extras_() { if(!this->extras_ptr_) { this->extras_ptr_.reset(new extras_type); } return *this->extras_ptr_; } /// INTERNAL ONLY void set_prefix_suffix_(BidiIter begin, BidiIter end) { this->base_ = begin; this->prefix_.first = begin; this->prefix_.second = (*this)[ 0 ].first; this->prefix_.matched = this->prefix_.first != this->prefix_.second; this->suffix_.first = (*this)[ 0 ].second; this->suffix_.second = end; this->suffix_.matched = this->suffix_.first != this->suffix_.second; typename nested_results_type::iterator ibegin = this->nested_results_.begin(); typename nested_results_type::iterator iend = this->nested_results_.end(); for( ; ibegin != iend; ++ibegin ) { ibegin->set_prefix_suffix_(begin, end); } } /// INTERNAL ONLY void reset_() { detail::core_access<BidiIter>::init_sub_match_vector(this->sub_matches_, 0, 0); } /// INTERNAL ONLY void set_base_(BidiIter base) { this->base_ = base; typename nested_results_type::iterator ibegin = this->nested_results_.begin(); typename nested_results_type::iterator iend = this->nested_results_.end(); for( ; ibegin != iend; ++ibegin ) { ibegin->set_base_(base); } } regex_id_type regex_id_; detail::sub_match_vector<BidiIter> sub_matches_; BidiIter base_; sub_match<BidiIter> prefix_; sub_match<BidiIter> suffix_; nested_results_type nested_results_; detail::action_state action_state_; shared_ptr<extras_type> extras_ptr_; }; /////////////////////////////////////////////////////////////////////////////// // action_state_cast /// INTERNAL ONLY template<typename State, typename BidiIter> inline State &action_state_cast(match_results<BidiIter> const &what) { return what.BOOST_NESTED_TEMPLATE get_action_state<State>(); } /////////////////////////////////////////////////////////////////////////////// // regex_id_filter_predicate // template<typename BidiIter> struct regex_id_filter_predicate : std::unary_function<match_results<BidiIter>, bool> { regex_id_filter_predicate(regex_id_type regex_id) : regex_id_(regex_id) { } bool operator ()(match_results<BidiIter> const &res) const { return this->regex_id_ == res.regex_id(); } private: regex_id_type regex_id_; }; }} // namespace boost::xpressive #endif