Issue 1181: Invalid sub_match comparison operators

Title: Invalid sub_match comparison operators
Status: c++11
Section: [re.submatch.op]
Submitter: Daniel Krügler

Created on 2009-07-25.00:00:00 last changed 162 months ago

Messages

Date: 2010-11-24.14:01:03

Proposed resolution:

The wording refers to N3126.

Change 28.9.2 [re.submatch.op]/7 as indicated:

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

7 Returns: lhs == rhs.str()rhs.compare(lhs.c_str()) == 0.

Change 28.9.2 [re.submatch.op]/8 as indicated:

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

8 Returns: lhs != rhs.str()!(lhs == rhs).

Change 28.9.2 [re.submatch.op]/9 as indicated:

template <class BiIter, class ST, class SA>
 bool operator<(
   const basic_string<
     typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
   const sub_match<BiIter>& rhs);

9 Returns: lhs < rhs.str()rhs.compare(lhs.c_str()) > 0.

Change 28.9.2 [re.submatch.op]/10 as indicated:

template <class BiIter, class ST, class SA>
 bool operator>(
   const basic_string<
     typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
   const sub_match<BiIter>& rhs);

10 Returns: lhs > rhs.str()rhs < lhs.

Change 28.9.2 [re.submatch.op]/11 as indicated:

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

11 Returns: lhs >= rhs.str()!(lhs < rhs).

Change 28.9.2 [re.submatch.op]/12 as indicated:

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

12 Returns: lhs <= rhs.str()!(rhs < lhs).

Change 28.9.2 [re.submatch.op]/13 as indicated:

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

13 Returns: lhs.str() == rhslhs.compare(rhs.c_str()) == 0.

Change 28.9.2 [re.submatch.op]/14 as indicated:

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

14 Returns: lhs.str() != rhs!(lhs == rhs).

Change 28.9.2 [re.submatch.op]/15 as indicated:

template <class BiIter, class ST, class SA>
 bool operator<(const sub_match<BiIter>& lhs,
   const basic_string<
     typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

15 Returns: lhs.str() < rhslhs.compare(rhs.c_str()) < 0.

Change 28.9.2 [re.submatch.op]/16 as indicated:

template <class BiIter, class ST, class SA>
 bool operator>(const sub_match<BiIter>& lhs,
   const basic_string<
     typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);

16 Returns: lhs.str() > rhsrhs < lhs.

Change 28.9.2 [re.submatch.op]/17 as indicated:

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

17 Returns: lhs.str() >= rhs!(lhs < rhs).

Change 28.9.2 [re.submatch.op]/18 as indicated:

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

18 Returns: lhs.str() <= rhs!(rhs < lhs).

Change 28.9.2 [re.submatch.op]/19 as indicated:

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

19 Returns: lhs == rhs.str()rhs.compare(lhs) == 0.

Change 28.9.2 [re.submatch.op]/20 as indicated:

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

20 Returns: lhs != rhs.str()!(lhs == rhs).

Change 28.9.2 [re.submatch.op]/21 as indicated:

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

21 Returns: lhs < rhs.str()rhs.compare(lhs) > 0.

Change 28.9.2 [re.submatch.op]/22 as indicated:

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

22 Returns: lhs > rhs.str()rhs < lhs.

Change 28.9.2 [re.submatch.op]/23 as indicated:

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

23 Returns: lhs >= rhs.str()!(lhs < rhs).

Change 28.9.2 [re.submatch.op]/24 as indicated:

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

24 Returns: lhs <= rhs.str()!(rhs < lhs).

Change 28.9.2 [re.submatch.op]/25 as indicated:

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

25 Returns: lhs.str() == rhslhs.compare(rhs) == 0.

Change 28.9.2 [re.submatch.op]/26 as indicated:

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

26 Returns: lhs.str() != rhs!(lhs == rhs).

Change 28.9.2 [re.submatch.op]/27 as indicated:

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

27 Returns: lhs.str() < rhslhs.compare(rhs) < 0.

Change 28.9.2 [re.submatch.op]/28 as indicated:

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

28 Returns: lhs.str() > rhsrhs < lhs.

Change 28.9.2 [re.submatch.op]/29 as indicated:

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

29 Returns: lhs.str() >= rhs!(lhs < rhs).

Change 28.9.2 [re.submatch.op]/30 as indicated:

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

30 Returns: lhs.str() <= rhs!(rhs < lhs).

Change 28.9.2 [re.submatch.op]/31 as indicated:
```
template <class BiIter>
 bool operator==(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
~~31 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) == rhs.str().~~
31 Returns: rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0.
Change 28.9.2 [re.submatch.op]/32 as indicated:
```
template <class BiIter>
 bool operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
32 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) != rhs.str()!(lhs == rhs).
Change 28.9.2 [re.submatch.op]/33 as indicated:
```
template <class BiIter>
 bool operator<(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
~~33 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) < rhs.str().~~
33 Returns: rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0.
Change 28.9.2 [re.submatch.op]/34 as indicated:
```
template <class BiIter>
 bool operator>(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
34 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) > rhs.str()rhs < lhs.
Change 28.9.2 [re.submatch.op]/35 as indicated:
```
template <class BiIter>
 bool operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
35 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) >= rhs.str()!(lhs < rhs).
Change 28.9.2 [re.submatch.op]/36 as indicated:
```
template <class BiIter>
 bool operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
   const sub_match<BiIter>& rhs);
```
36 Returns: basic_string<typename iterator_traits<BiIter>::value_type>(1, lhs) <= rhs.str()!(rhs < lhs).
Change 28.9.2 [re.submatch.op]/37 as indicated:
```
template <class BiIter>
 bool operator==(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
~~37 Returns: lhs.str() == basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs).~~
37 Returns: lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0.
Change 28.9.2 [re.submatch.op]/38 as indicated:
```
template <class BiIter>
 bool operator!=(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
38 Returns: lhs.str() != basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs)!(lhs == rhs).
Change 28.9.2 [re.submatch.op]/39 as indicated:
```
template <class BiIter>
 bool operator<(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
~~39 Returns: lhs.str() < basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs).~~
39 Returns: lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0.
Change 28.9.2 [re.submatch.op]/40 as indicated:
```
template <class BiIter>
 bool operator>(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
40 Returns: lhs.str() > basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs)rhs < lhs.
Change 28.9.2 [re.submatch.op]/41 as indicated:
```
template <class BiIter>
 bool operator>=(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
41 Returns: lhs.str() >= basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs)!(lhs < rhs).
Change 28.9.2 [re.submatch.op]/42 as indicated:
```
template <class BiIter>
 bool operator<=(const sub_match<BiIter>& lhs,
   typename iterator_traits<BiIter>::value_type const& rhs);
```
42 Returns: lhs.str() <= basic_string<typename iterator_traits<BiIter>::value_type>(1, rhs)!(rhs < lhs).

msg4762 (view)

Date: 2010-11-24.14:01:03

[ Adopted at 2010-11 Batavia ]

msg1042 (view)

Date: 2010-10-21.19:06:53

[ Post-Rapperswil ]

The following update is a result of the discussion during the Rapperswil meeting, the P/R expresses all comparisons by delegating to sub_match's compare functions. The processing is rather mechanical: Only == and < where defined by referring to sub_match's compare function, all remaining ones where replaced by the canonical definitions in terms of these two.

Moved to Tentatively Ready after 5 positive votes on c++std-lib.

msg1041 (view)

Date: 2009-07-25.00:00:00

Several heterogeneous comparison operators of class template sub_match are specified by return clauses that are not valid in general. E.g. [re.submatch.op]/7:

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

Returns: lhs == rhs.str().

The returns clause would be ill-formed for all cases where ST != std::char_traits<iterator_traits<BiIter>::value_type> or SA != std::allocator<iterator_traits<BiIter>::value_type>.

The generic character of the comparison was intended, so there are basically two approaches to fix the problem: The first one would define the semantics of the comparison using the traits class ST (The semantic of basic_string::compare is defined in terms of the compare function of the corresponding traits class), the second one would define the semantics of the comparison using the traits class

std::char_traits<iterator_traits<BiIter>::value_type>

which is essentially identical to

std::char_traits<sub_match<BiIter>::value_type>

I suggest to follow the second approach, because this emphasizes the central role of the sub_match object as part of the comparison and would also make sure that a sub_match comparison using some basic_string<char_t, ..> always is equivalent to a corresponding comparison with a string literal because of the existence of further overloads (beginning from [re.submatch.op]/19). If users really want to take advantage of their own traits::compare, they can simply write a corresponding compare function that does so.

History
Date	User	Action	Args
2011-08-23 20:07:26	admin	set	status: wp -> c++11
2010-11-24 14:01:03	admin	set	messages: + msg5417
2010-11-14 13:10:57	admin	set	status: voting -> wp
2010-11-08 14:14:39	admin	set	status: ready -> voting
2010-10-21 19:06:53	admin	set	messages: + msg4762
2010-10-21 19:06:53	admin	set	status: new -> ready
2010-10-21 18:28:33	admin	set	messages: + msg1042
2009-07-25 00:00:00	admin	create