///////////////////////////////////////////////////////////////////////////////

 /// \file sub_match.hpp

 /// Contains the definition of the class template sub_match\<\>

 /// and associated helper functions

 //

 //  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_SUB_MATCH_HPP_EAN_10_04_2005

 #define BOOST_XPRESSIVE_SUB_MATCH_HPP_EAN_10_04_2005

 // MS compatible compilers support #pragma once

 #if defined(_MSC_VER) && (_MSC_VER >= 1020)

 # pragma once

 #endif

 #include <iosfwd>

 #include <string>

 #include <utility>

 #include <iterator>

 #include <algorithm>

 #include <boost/iterator/iterator_traits.hpp>

 //{{AFX_DOC_COMMENT

 ///////////////////////////////////////////////////////////////////////////////

 // This is a hack to get Doxygen to show the inheritance relation between

 // sub_match<T> and std::pair<T,T>.

 #ifdef BOOST_XPRESSIVE_DOXYGEN_INVOKED

 /// INTERNAL ONLY

 namespace std

 {

     /// INTERNAL ONLY

     template<typename, typename> struct pair {};

 }

 #endif

 //}}AFX_DOC_COMMENT

 namespace boost { namespace xpressive

 {

 ///////////////////////////////////////////////////////////////////////////////

 // sub_match

 //

 /// \brief Class template sub_match denotes the sequence of characters matched by a particular marked sub-expression.

 ///

 /// When the marked sub-expression denoted by an object of type sub_match\<\> participated in a

 /// regular expression match then member matched evaluates to true, and members first and second

 /// denote the range of characters [first,second) which formed that match. Otherwise matched is false,

 /// and members first and second contained undefined values.

 ///

 /// If an object of type sub_match\<\> represents sub-expression 0 - that is to say the whole match -

 /// then member matched is always true, unless a partial match was obtained as a result of the flag

 /// match_partial being passed to a regular expression algorithm, in which case member matched is

 /// false, and members first and second represent the character range that formed the partial match.

 template<typename BidiIter>

 struct sub_match

   : std::pair<BidiIter, BidiIter>

 {

 private:

     struct dummy { int i_; };

     typedef int dummy::*bool_type;

 public:

     typedef typename iterator_value<BidiIter>::type value_type;

     typedef typename iterator_difference<BidiIter>::type difference_type;

     typedef std::basic_string<value_type> string_type;

     typedef BidiIter iterator;

     explicit sub_match(BidiIter first = BidiIter(), BidiIter second = BidiIter(), bool matched_ = false)

       : std::pair<BidiIter, BidiIter>(first, second)

       , matched(matched_)

     {

     }

     string_type str() const

     {

         return this->matched ? string_type(this->first, this->second) : string_type();

     }

     operator string_type() const

     {

         return this->matched ? string_type(this->first, this->second) : string_type();

     }

     difference_type length() const

     {

         return this->matched ? std::distance(this->first, this->second) : 0;

     }

     operator bool_type() const

     {

         return this->matched ? &dummy::i_ : 0;

     }

     bool operator !() const

     {

         return !this->matched;

     }

     /// \brief Performs a lexicographic string comparison

     /// \param str the string against which to compare

     /// \return the results of (*this).str().compare(str)

     int compare(string_type const &str) const

     {

         return this->str().compare(str);

     }

     /// \overload

     int compare(sub_match const &sub) const

     {

         return this->str().compare(sub.str());

     }

     /// \overload

     int compare(value_type const *ptr) const

     {

         return this->str().compare(ptr);

     }

     /// \brief true if this sub-match participated in the full match.

     bool matched;

 };

 ///////////////////////////////////////////////////////////////////////////////

 /// \brief insertion operator for sending sub-matches to ostreams

 /// \param sout output stream.

 /// \param sub sub_match object to be written to the stream.

 /// \return sout \<\< sub.str()

 template<typename BidiIter, typename Char, typename Traits>

 inline std::basic_ostream<Char, Traits> &operator <<

 (

     std::basic_ostream<Char, Traits> &sout

   , sub_match<BidiIter> const &sub

 )

 {

     typedef typename iterator_value<BidiIter>::type char_type;

     if(sub.matched)

     {

         std::ostream_iterator<char_type, Char, Traits> iout(sout);

         std::copy(sub.first, sub.second, iout);

     }

     return sout;

 }

 // BUGBUG make these more efficient

 template<typename BidiIter>

 bool operator == (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs) == 0;

 }

 template<typename BidiIter>

 bool operator != (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs) != 0;

 }

 template<typename BidiIter>

 bool operator < (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs) < 0;

 }

 template<typename BidiIter>

 bool operator <= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs) <= 0;

 }

 template<typename BidiIter>

 bool operator >= (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs)>= 0;

 }

 template<typename BidiIter>

 bool operator> (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs.compare(rhs)> 0;

 }

 template<typename BidiIter>

 bool operator == (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs == rhs.str();

 }

 template<typename BidiIter>

 bool operator != (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs != rhs.str();

 }

 template<typename BidiIter>

 bool operator < (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs < rhs.str();

 }

 template<typename BidiIter>

 bool operator> (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs> rhs.str();

 }

 template<typename BidiIter>

 bool operator >= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs >= rhs.str();

 }

 template<typename BidiIter>

 bool operator <= (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs <= rhs.str();

 }

 template<typename BidiIter>

 bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str() == rhs;

 }

 template<typename BidiIter>

 bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str() != rhs;

 }

 template<typename BidiIter>

 bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str() < rhs;

 }

 template<typename BidiIter>

 bool operator> (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str()> rhs;

 }

 template<typename BidiIter>

 bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str()>= rhs;

 }

 template<typename BidiIter>

 bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs)

 {

     return lhs.str() <= rhs;

 }

 template<typename BidiIter>

 bool operator == (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs == rhs.str();

 }

 template<typename BidiIter>

 bool operator != (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs != rhs.str();

 }

 template<typename BidiIter>

 bool operator < (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs < rhs.str();

 }

 template<typename BidiIter>

 bool operator> (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs> rhs.str();

 }

 template<typename BidiIter>

 bool operator >= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs >= rhs.str();

 }

 template<typename BidiIter>

 bool operator <= (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs)

 {

     return lhs <= rhs.str();

 }

 template<typename BidiIter>

 bool operator == (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str() == rhs;

 }

 template<typename BidiIter>

 bool operator != (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str() != rhs;

 }

 template<typename BidiIter>

 bool operator < (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str() < rhs;

 }

 template<typename BidiIter>

 bool operator> (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str()> rhs;

 }

 template<typename BidiIter>

 bool operator >= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str()>= rhs;

 }

 template<typename BidiIter>

 bool operator <= (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs)

 {

     return lhs.str() <= rhs;

 }

 }} // namespace boost::xpressive

 #endif