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