| /////////////////////////////////////////////////////////////////////////////// |
| /// \file sub_match.hpp |
| /// Contains the definition of the class template sub_match\<\> |
| /// and associated helper functions |
| // |
| // Copyright 2008 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> |
| #include <boost/xpressive/detail/detail_fwd.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: |
| /// INTERNAL ONLY |
| /// |
| 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 typename detail::string_type<value_type>::type string_type; |
| typedef BidiIter iterator; |
| |
| sub_match() |
| : std::pair<BidiIter, BidiIter>() |
| , matched(false) |
| { |
| } |
| |
| sub_match(BidiIter first, BidiIter second, 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; |
| } |
| |
| // Operator+ convenience function |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (sub_match<BidiIter> const &lhs, sub_match<BidiIter> const &rhs) |
| { |
| return lhs.str() + rhs.str(); |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const &rhs) |
| { |
| return lhs.str() + rhs; |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (typename iterator_value<BidiIter>::type const &lhs, sub_match<BidiIter> const &rhs) |
| { |
| return lhs + rhs.str(); |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (sub_match<BidiIter> const &lhs, typename iterator_value<BidiIter>::type const *rhs) |
| { |
| return lhs.str() + rhs; |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (typename iterator_value<BidiIter>::type const *lhs, sub_match<BidiIter> const &rhs) |
| { |
| return lhs + rhs.str(); |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (sub_match<BidiIter> const &lhs, typename sub_match<BidiIter>::string_type const &rhs) |
| { |
| return lhs.str() + rhs; |
| } |
| |
| template<typename BidiIter> |
| typename sub_match<BidiIter>::string_type |
| operator + (typename sub_match<BidiIter>::string_type const &lhs, sub_match<BidiIter> const &rhs) |
| { |
| return lhs + rhs.str(); |
| } |
| |
| }} // namespace boost::xpressive |
| |
| #endif |