| [/ |
| Copyright 2006-2007 John Maddock. |
| 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). |
| ] |
| |
| |
| [section:sub_match 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 |
| [link boost_regex.partial_matches 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 ``[link boost_regex.sub_match.value_type value_type]``; |
| typedef typename iterator_traits<BidirectionalIterator>::difference_type ``[link boost_regex.sub_match.diff_type difference_type]``; |
| typedef BidirectionalIterator ``[link boost_regex.sub_match.it_type iterator]``; |
| |
| bool ``[link boost_regex.sub_match.matched matched]``; |
| |
| difference_type ``[link boost_regex.sub_match.length length]``()const; |
| ``[link boost_regex.sub_match.cast operator basic_string<value_type>]``()const; |
| basic_string<value_type> ``[link boost_regex.sub_match.str str]``()const; |
| |
| int ``[link boost_regex.sub_match.compare1 compare]``(const sub_match& s)const; |
| int ``[link boost_regex.sub_match.compare2 compare]``(const basic_string<value_type>& s)const; |
| int ``[link boost_regex.sub_match.compare3 compare]``(const value_type* s)const; |
| #ifdef BOOST_REGEX_MATCH_EXTRA |
| typedef implementation-private ``[link boost_regex.sub_match.cap_seq_type capture_sequence_type]``; |
| const capture_sequence_type& ``[link boost_regex.sub_match.captures captures]``()const; |
| #endif |
| }; |
| // |
| // comparisons to another sub_match: |
| // |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare1 operator ==]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare2 operator !=]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare3 operator <]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare4 operator <=]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare5 operator >=]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare6 operator >]`` (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| |
| // |
| // comparisons to a basic_string: |
| // |
| template <class BidirectionalIterator, class traits, class Allocator> |
| bool ``[link boost_regex.sub_match.op_compare7 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 ``[link boost_regex.sub_match.op_compare8 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 ``[link boost_regex.sub_match.op_compare9 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 ``[link boost_regex.sub_match.op_compare10 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 ``[link boost_regex.sub_match.op_compare11 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 ``[link boost_regex.sub_match.op_compare12 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 ``[link boost_regex.sub_match.op_compare13 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 ``[link boost_regex.sub_match.op_compare14 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 ``[link boost_regex.sub_match.op_compare15 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 ``[link boost_regex.sub_match.op_compare16 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 ``[link boost_regex.sub_match.op_compare17 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 ``[link boost_regex.sub_match.op_compare18 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 ``[link boost_regex.sub_match.op_compare19 operator == ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare20 operator != ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare21 operator < ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare22 operator > ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare23 operator >= ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare24 operator <= ]``(typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare25 operator == ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare26 operator != ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare27 operator < ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare28 operator > ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare29 operator >= ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare30 operator <= ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| // |
| // comparisons to a single character: |
| // |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare31 operator == ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare32 operator != ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare33 operator < ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare34 operator > ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare35 operator >= ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare36 operator <= ]``(typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare37 operator == ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare38 operator != ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare39 operator < ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare40 operator > ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare41 operator >= ]``(const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| template <class BidirectionalIterator> |
| bool ``[link boost_regex.sub_match.op_compare42 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> |
| ``[link boost_regex.sub_match.op_add1 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> |
| ``[link boost_regex.sub_match.op_add2 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> |
| ``[link boost_regex.sub_match.op_add3 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> |
| ``[link boost_regex.sub_match.op_add4 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> |
| ``[link boost_regex.sub_match.op_add5 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> |
| ``[link boost_regex.sub_match.op_add6 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> |
| ``[link boost_regex.sub_match.op_add7 operator + ]``(const sub_match<BidirectionalIterator>& m1, |
| const sub_match<BidirectionalIterator>& m2); |
| |
| // |
| // stream inserter: |
| // |
| template <class charT, class traits, class BidirectionalIterator> |
| basic_ostream<charT, traits>& |
| ``[link boost_regex.sub_match.op_stream operator << ]``(basic_ostream<charT, traits>& os, |
| const sub_match<BidirectionalIterator>& m); |
| |
| } // namespace boost |
| |
| [h4 Description] |
| |
| [h5 Members] |
| |
| [#boost_regex.sub_match.value_type] |
| |
| typedef typename std::iterator_traits<iterator>::value_type value_type; |
| |
| The type pointed to by the iterators. |
| |
| [#boost_regex.sub_match.diff_type] |
| |
| typedef typename std::iterator_traits<iterator>::difference_type difference_type; |
| |
| A type that represents the difference between two iterators. |
| |
| [#boost_regex.sub_match.it_type] |
| |
| typedef BidirectionalIterator iterator; |
| |
| The iterator type. |
| |
| [#boost_regex.sub_match.first] |
| |
| iterator first |
| |
| An iterator denoting the position of the start of the match. |
| |
| [#boost_regex.sub_match.second] |
| |
| iterator second |
| |
| An iterator denoting the position of the end of the match. |
| |
| [#boost_regex.sub_match.matched] |
| |
| bool matched |
| |
| A Boolean value denoting whether this sub-expression participated in the match. |
| |
| [#boost_regex.sub_match.length] |
| |
| 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)`. |
| |
| [#boost_regex.sub_match.cast] |
| |
| operator basic_string<value_type>()const; |
| |
| [*Effects]: converts `*this` into a string: returns |
| `(matched ? basic_string<value_type>(first, second) : basic_string<value_type>())`. |
| |
| [#boost_regex.sub_match.str] |
| |
| basic_string<value_type> str()const; |
| |
| [*Effects]: returns a string representation of `*this`: |
| `(matched ? basic_string<value_type>(first, second) : basic_string<value_type>())`. |
| |
| [#boost_regex.sub_match.compare1] |
| |
| int compare(const sub_match& s)const; |
| |
| [*Effects]: performs a lexical comparison to /s/: returns `str().compare(s.str())`. |
| |
| [#boost_regex.sub_match.compare2] |
| |
| int compare(const basic_string<value_type>& s)const; |
| |
| [*Effects]: compares `*this` to the string /s/: returns `str().compare(s)`. |
| |
| [#boost_regex.sub_match.compare3] |
| |
| int compare(const value_type* s)const; |
| |
| [*Effects]: compares `*this` to the null-terminated string /s/: returns `str().compare(s)`. |
| |
| [#boost_regex.sub_match.cap_seq_type] |
| |
| 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. |
| |
| [#boost_regex.sub_match.captures] |
| |
| 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 occupies more memory resulting in complex expressions running out of memory or stack space more quickly during matching. |
| * The matching algorithms are less efficient at handling some features (independent sub-expressions for example), even when match_extra is not used. |
| * The matching algorithms are much less efficient (i.e. slower), when match_extra is used. Mostly this is down to the extra memory allocations that have to take place. |
| |
| [h5 sub_match non-member operators] |
| |
| [#boost_regex.sub_match.op_compare1] |
| |
| template <class BidirectionalIterator> |
| bool operator == (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) == 0`. |
| |
| [#boost_regex.sub_match.op_compare2] |
| |
| template <class BidirectionalIterator> |
| bool operator != (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) != 0`. |
| |
| [#boost_regex.sub_match.op_compare3] |
| |
| template <class BidirectionalIterator> |
| bool operator < (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) < 0`. |
| |
| [#boost_regex.sub_match.op_compare4] |
| |
| template <class BidirectionalIterator> |
| bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) <= 0`. |
| |
| [#boost_regex.sub_match.op_compare5] |
| |
| template <class BidirectionalIterator> |
| bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) >= 0`. |
| |
| [#boost_regex.sub_match.op_compare6] |
| |
| template <class BidirectionalIterator> |
| bool operator > (const sub_match<BidirectionalIterator>& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs.compare(rhs) > 0`. |
| |
| [#boost_regex.sub_match.op_compare7] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare8] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare9] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare10] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare11] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare12] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_compare13] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare14] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare15] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare16] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare17] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare18] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_compare19] |
| |
| template <class BidirectionalIterator> |
| bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs == rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare20] |
| |
| template <class BidirectionalIterator> |
| bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs != rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare21] |
| |
| template <class BidirectionalIterator> |
| bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs < rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare22] |
| |
| template <class BidirectionalIterator> |
| bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs > rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare23] |
| |
| template <class BidirectionalIterator> |
| bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs >= rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare24] |
| |
| template <class BidirectionalIterator> |
| bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs <= rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare25] |
| |
| template <class BidirectionalIterator> |
| bool operator == (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() == rhs`. |
| |
| [#boost_regex.sub_match.op_compare26] |
| |
| template <class BidirectionalIterator> |
| bool operator != (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() != rhs`. |
| |
| [#boost_regex.sub_match.op_compare27] |
| |
| template <class BidirectionalIterator> |
| bool operator < (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() < rhs`. |
| |
| [#boost_regex.sub_match.op_compare28] |
| |
| template <class BidirectionalIterator> |
| bool operator > (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() > rhs`. |
| |
| [#boost_regex.sub_match.op_compare29] |
| |
| template <class BidirectionalIterator> |
| bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() >= rhs`. |
| |
| [#boost_regex.sub_match.op_compare30] |
| |
| template <class BidirectionalIterator> |
| bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
| |
| [*Effects]: returns `lhs.str() <= rhs`. |
| |
| [#boost_regex.sub_match.op_compare31] |
| |
| template <class BidirectionalIterator> |
| bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs == rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare32] |
| |
| template <class BidirectionalIterator> |
| bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs != rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare33] |
| |
| template <class BidirectionalIterator> |
| bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs < rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare34] |
| |
| template <class BidirectionalIterator> |
| bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs > rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare35] |
| |
| template <class BidirectionalIterator> |
| bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs >= rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare36] |
| |
| template <class BidirectionalIterator> |
| bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
| const sub_match<BidirectionalIterator>& rhs); |
| |
| [*Effects]: returns `lhs <= rhs.str()`. |
| |
| [#boost_regex.sub_match.op_compare37] |
| |
| template <class BidirectionalIterator> |
| bool operator == (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| |
| [*Effects]: returns `lhs.str() == rhs`. |
| |
| [#boost_regex.sub_match.op_compare38] |
| |
| template <class BidirectionalIterator> |
| bool operator != (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| |
| [*Effects]: returns `lhs.str() != rhs`. |
| |
| [#boost_regex.sub_match.op_compare39] |
| |
| template <class BidirectionalIterator> |
| bool operator < (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| |
| [*Effects]: returns `lhs.str() < rhs`. |
| |
| [#boost_regex.sub_match.op_compare40] |
| |
| template <class BidirectionalIterator> |
| bool operator > (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| |
| [*Effects]: returns `lhs.str() > rhs`. |
| |
| [#boost_regex.sub_match.op_compare41] |
| |
| template <class BidirectionalIterator> |
| bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
| typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
| |
| [*Effects]: returns `lhs.str() >= rhs`. |
| |
| [#boost_regex.sub_match.op_compare42] |
| |
| 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. |
| |
| [#boost_regex.sub_match.op_add1] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_add2] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_add3] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_add4] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_add5] |
| |
| 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()`. |
| |
| [#boost_regex.sub_match.op_add6] |
| |
| 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`. |
| |
| [#boost_regex.sub_match.op_add7] |
| |
| 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()`. |
| |
| [h5 Stream inserter] |
| |
| [#boost_regex.sub_match.op_stream] |
| |
| 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())`. |
| |
| [endsect] |
| |
