851 lines
39 KiB
Plaintext
851 lines
39 KiB
Plaintext
[/
|
|
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]
|
|
|