Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

sub_match

#include <boost/regex.hpp>

Regular expressions are different from many simple pattern-matching algorithms in that as well as finding an overall match they can also produce sub-expression matches: each sub-expression being delimited in the pattern by a pair of parenthesis (...). There has to be some method for reporting sub-expression matches back to the user: this is achieved this by defining a class match_results that acts as an indexed collection of sub-expression matches, each sub-expression match being contained in an object of type sub_match.

Objects of type sub_match may only be obtained by subscripting an object of type match_results.

Objects of type sub_match may be compared to objects of type std::basic_string, or const charT* or const charT.

Objects of type sub_match may be added to objects of type std::basic_string, or const charT* or const charT, to produce a new std::basic_string object.

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.

When the marked sub-expression denoted by an object of type sub_match was repeated, then the sub_match object represents the match obtained by the last repeat. The complete set of all the captures obtained for all the repeats, may be accessed via the captures() member function (Note: this has serious performance implications, you have to explicitly enable this feature).

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.

namespace boost{

template <class BidirectionalIterator>
class sub_match;

typedef sub_match<const char*>                    csub_match;
typedef sub_match<const wchar_t*>                 wcsub_match;
typedef sub_match<std::string::const_iterator>    ssub_match;
typedef sub_match<std::wstring::const_iterator>   wssub_match;

template <class BidirectionalIterator>
class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator>
{
public:
   typedef typename iterator_traits<BidirectionalIterator>::value_type       value_type;
   typedef typename iterator_traits<BidirectionalIterator>::difference_type  difference_type;
   typedef          BidirectionalIterator                                    iterator;

   bool matched;

   difference_type length()const;
   operator basic_string<value_type>()const;
   basic_string<value_type> str()const;

   int compare(const sub_match& s)const;
   int compare(const basic_string<value_type>& s)const;
   int compare(const value_type* s)const;
#ifdef BOOST_REGEX_MATCH_EXTRA
   typedef implementation-private capture_sequence_type;
   const capture_sequence_type& captures()const;
#endif
};
//
// comparisons to another sub_match:
//
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);


//
// comparisons to a basic_string:
//
template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);
template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

//
// comparisons to a pointer to a character array:
//
template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

//
// comparisons to a single character:
//
template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);
template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);
// 
// addition operators: 
//
template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const sub_match<BidirectionalIterator>& m,
               const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const * s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
               const sub_match<BidirectionalIterator>& m);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const& s);
template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m1,
               const sub_match<BidirectionalIterator>& m2);

//
// stream inserter:
//
template <class charT, class traits, class BidirectionalIterator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os,
               const sub_match<BidirectionalIterator>& m);

} // namespace boost
Description
Members
typedef typename std::iterator_traits<iterator>::value_type value_type;

The type pointed to by the iterators.

typedef typename std::iterator_traits<iterator>::difference_type difference_type;

A type that represents the difference between two iterators.

typedef BidirectionalIterator iterator;

The iterator type.

iterator first

An iterator denoting the position of the start of the match.

iterator second

An iterator denoting the position of the end of the match.

bool matched

A Boolean value denoting whether this sub-expression participated in the match.

static difference_type length();

Effects: returns the length of this matched sub-expression, or 0 if this sub-expression was not matched: matched ? distance(first, second) : 0).

operator basic_string<value_type>()const;

Effects: converts *this into a string: returns (matched ? basic_string<value_type>(first, second) : basic_string<value_type>()).

basic_string<value_type> str()const;

Effects: returns a string representation of *this: (matched ? basic_string<value_type>(first, second) : basic_string<value_type>()).

int compare(const sub_match& s)const;

Effects: performs a lexical comparison to s: returns str().compare(s.str()).

int compare(const basic_string<value_type>& s)const;

Effects: compares *this to the string s: returns str().compare(s).

int compare(const value_type* s)const;

Effects: compares *this to the null-terminated string s: returns str().compare(s).

typedef implementation-private capture_sequence_type;

Defines an implementation-specific type that satisfies the requirements of a standard library Sequence (21.1.1 including the optional Table 68 operations), whose value_type is a sub_match<BidirectionalIterator>. This type happens to be std::vector<sub_match<BidirectionalIterator> >, but you shouldn't actually rely on that.

const capture_sequence_type& captures()const;

Effects: returns a sequence containing all the captures obtained for this sub-expression.

Preconditions: the library must be built and used with BOOST_REGEX_MATCH_EXTRA defined, and you must pass the flag match_extra to the regex matching functions ( regex_match, regex_search, regex_iterator or regex_token_iterator) in order for this member #function to be defined and return useful information.

Rationale: Enabling this feature has several consequences:

sub_match non-member operators
template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) == 0.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) != 0.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) < 0.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) <= 0.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) >= 0.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs.compare(rhs) > 0.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                          traits,
                                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs == rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                          traits,
                                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs != rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                         traits,
                                         Allocator>& lhs,
                 const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs < rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                                         traits,
                                                         Allocator>& lhs,
                 const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs > rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs >= rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs <= rhs.str().

template <class BidirectionalIterator, class traits, class Allocator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Effects: returns lhs.str() == rhs.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Effects: returns lhs.str() != rhs.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& rhs);

Effects: returns lhs.str() < rhs.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
                 const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                         traits,
                                         Allocator>& rhs);

Effects: returns lhs.str() > rhs.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Effects: returns lhs.str() >= rhs.

template <class BidirectionalIterator, class traits, class Allocator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  const std::basic_string<iterator_traits<BidirectionalIterator>::value_type,
                                          traits,
                                          Allocator>& rhs);

Effects: returns lhs.str() <= rhs.

template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs == rhs.str().

template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs != rhs.str().

template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs < rhs.str().

template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs > rhs.str().

template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs >= rhs.str().

template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs <= rhs.str().

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() == rhs.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() != rhs.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() < rhs.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() > rhs.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() >= rhs.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const* rhs);

Effects: returns lhs.str() <= rhs.

template <class BidirectionalIterator>
bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs == rhs.str().

template <class BidirectionalIterator>
bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs != rhs.str().

template <class BidirectionalIterator>
bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs < rhs.str().

template <class BidirectionalIterator>
bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
               const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs > rhs.str().

template <class BidirectionalIterator>
bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs >= rhs.str().

template <class BidirectionalIterator>
bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs,
                  const sub_match<BidirectionalIterator>& rhs);

Effects: returns lhs <= rhs.str().

template <class BidirectionalIterator>
bool operator == (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() == rhs.

template <class BidirectionalIterator>
bool operator != (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() != rhs.

template <class BidirectionalIterator>
bool operator < (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() < rhs.

template <class BidirectionalIterator>
bool operator > (const sub_match<BidirectionalIterator>& lhs,
               typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() > rhs.

template <class BidirectionalIterator>
bool operator >= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() >= rhs.

template <class BidirectionalIterator>
bool operator <= (const sub_match<BidirectionalIterator>& lhs,
                  typename iterator_traits<BidirectionalIterator>::value_type const& rhs);

Effects: returns lhs.str() <= rhs.

The addition operators for sub_match allow you to add a sub_match to any type to which you can add a std::string and obtain a new string as the result.

template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s,
               const sub_match<BidirectionalIterator>& m);

Effects: returns s + m.str().

template <class BidirectionalIterator, class traits, class Allocator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>
   operator + (const sub_match<BidirectionalIterator>& m,
               const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type,
                                       traits,
                                       Allocator>& s);

Effects: returns m.str() + s.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s,
               const sub_match<BidirectionalIterator>& m);

Effects: returns s + m.str().

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const * s);

Effects: returns m.str() + s.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s,
               const sub_match<BidirectionalIterator>& m);

Effects: returns s + m.str().

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m,
               typename iterator_traits<BidirectionalIterator>::value_type const& s);

Effects: returns m.str() + s.

template <class BidirectionalIterator>
std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type>
   operator + (const sub_match<BidirectionalIterator>& m1,
               const sub_match<BidirectionalIterator>& m2);

Effects: returns m1.str() + m2.str().

Stream inserter
template <class charT, class traits, class BidirectionalIterator>
basic_ostream<charT, traits>&
   operator << (basic_ostream<charT, traits>& os
               const sub_match<BidirectionalIterator>& m);

Effects: returns (os << m.str()).


PrevUpHomeNext