sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: /// \file sub_match.hpp
sl@0: /// Contains the definition of the class template sub_match\<\>
sl@0: /// and associated helper functions
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_SUB_MATCH_HPP_EAN_10_04_2005
sl@0: #define BOOST_XPRESSIVE_SUB_MATCH_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 <iosfwd>
sl@0: #include <string>
sl@0: #include <utility>
sl@0: #include <iterator>
sl@0: #include <algorithm>
sl@0: #include <boost/iterator/iterator_traits.hpp>
sl@0: 
sl@0: //{{AFX_DOC_COMMENT
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // This is a hack to get Doxygen to show the inheritance relation between
sl@0: // sub_match<T> and std::pair<T,T>.
sl@0: #ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED
sl@0: /// INTERNAL ONLY
sl@0: namespace std
sl@0: {
sl@0:     /// INTERNAL ONLY
sl@0:     template<typename, typename> struct pair {};
sl@0: }
sl@0: #endif
sl@0: //}}AFX_DOC_COMMENT
sl@0: 
sl@0: namespace boost { namespace xpressive
sl@0: {
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: // sub_match
sl@0: //
sl@0: /// \brief Class template sub_match denotes the sequence of characters matched by a particular marked sub-expression.
sl@0: ///
sl@0: /// When the marked sub-expression denoted by an object of type sub_match\<\> participated in a
sl@0: /// regular expression match then member matched evaluates to true, and members first and second
sl@0: /// denote the range of characters [first,second) which formed that match. Otherwise matched is false,
sl@0: /// and members first and second contained undefined values.
sl@0: ///
sl@0: /// If an object of type sub_match\<\> represents sub-expression 0 - that is to say the whole match -
sl@0: /// then member matched is always true, unless a partial match was obtained as a result of the flag
sl@0: /// match_partial being passed to a regular expression algorithm, in which case member matched is
sl@0: /// false, and members first and second represent the character range that formed the partial match.
sl@0: template<typename BidiIter>
sl@0: struct sub_match
sl@0:   : std::pair<BidiIter, BidiIter>
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 value_type;
sl@0:     typedef typename iterator_difference<BidiIter>::type difference_type;
sl@0:     typedef std::basic_string<value_type> string_type;
sl@0:     typedef BidiIter iterator;
sl@0: 
sl@0:     explicit sub_match(BidiIter first = BidiIter(), BidiIter second = BidiIter(), bool matched_ = false)
sl@0:       : std::pair<BidiIter, BidiIter>(first, second)
sl@0:       , matched(matched_)
sl@0:     {
sl@0:     }
sl@0: 
sl@0:     string_type str() const
sl@0:     {
sl@0:         return this->matched ? string_type(this->first, this->second) : string_type();
sl@0:     }
sl@0: 
sl@0:     operator string_type() const
sl@0:     {
sl@0:         return this->matched ? string_type(this->first, this->second) : string_type();
sl@0:     }
sl@0: 
sl@0:     difference_type length() const
sl@0:     {
sl@0:         return this->matched ? std::distance(this->first, this->second) : 0;
sl@0:     }
sl@0: 
sl@0:     operator bool_type() const
sl@0:     {
sl@0:         return this->matched ? &dummy::i_ : 0;
sl@0:     }
sl@0: 
sl@0:     bool operator !() const
sl@0:     {
sl@0:         return !this->matched;
sl@0:     }
sl@0: 
sl@0:     /// \brief Performs a lexicographic string comparison
sl@0:     /// \param str the string against which to compare
sl@0:     /// \return the results of (*this).str().compare(str)
sl@0:     int compare(string_type const &str) const
sl@0:     {
sl@0:         return this->str().compare(str);
sl@0:     }
sl@0: 
sl@0:     /// \overload
sl@0:     int compare(sub_match const &sub) const
sl@0:     {
sl@0:         return this->str().compare(sub.str());
sl@0:     }
sl@0: 
sl@0:     /// \overload
sl@0:     int compare(value_type const *ptr) const
sl@0:     {
sl@0:         return this->str().compare(ptr);
sl@0:     }
sl@0: 
sl@0:     /// \brief true if this sub-match participated in the full match.
sl@0:     bool matched;
sl@0: };
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////
sl@0: /// \brief insertion operator for sending sub-matches to ostreams
sl@0: /// \param sout output stream.
sl@0: /// \param sub sub_match object to be written to the stream.
sl@0: /// \return sout \<\< sub.str()
sl@0: template<typename BidiIter, typename Char, typename Traits>
sl@0: inline std::basic_ostream<Char, Traits> &operator <<
sl@0: (
sl@0:     std::basic_ostream<Char, Traits> &sout
sl@0:   , sub_match<BidiIter> const &sub
sl@0: )
sl@0: {
sl@0:     typedef typename iterator_value<BidiIter>::type char_type;
sl@0:     if(sub.matched)
sl@0:     {
sl@0:         std::ostream_iterator<char_type, Char, Traits> iout(sout);
sl@0:         std::copy(sub.first, sub.second, iout);
sl@0:     }
sl@0:     return sout;
sl@0: }
sl@0: 
sl@0: 
sl@0: // BUGBUG make these more efficient
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator == (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs) == 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator != (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs) != 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator < (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs) < 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator <= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs) <= 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator >= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs)>= 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator> (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs.compare(rhs)> 0;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator == (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs == rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator != (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs != rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator < (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs < rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator> (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs> rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator >= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs >= rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator <= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs <= rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str() == rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str() != rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str() < rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator> (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str()> rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str()>= rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)
sl@0: {
sl@0:     return lhs.str() <= rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator == (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs == rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator != (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs != rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator < (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs < rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator> (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs> rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator >= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs >= rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator <= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)
sl@0: {
sl@0:     return lhs <= rhs.str();
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str() == rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str() != rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str() < rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator> (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str()> rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str()>= rhs;
sl@0: }
sl@0: 
sl@0: template<typename BidiIter>
sl@0: bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)
sl@0: {
sl@0:     return lhs.str() <= rhs;
sl@0: }
sl@0: 
sl@0: }} // namespace boost::xpressive
sl@0: 
sl@0: #endif