[re.iter] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpea30g8m7/{from.md → to.md} +17 -17

tmp/tmpea30g8m7/{from.md → to.md} RENAMED Viewed

@@ -1,10 +1,10 @@
-## Regular expression iterators <a id="re.iter">[[re.iter]]</a>
-### Class template `regex_iterator` <a id="re.regiter">[[re.regiter]]</a>
-#### General <a id="re.regiter.general">[[re.regiter.general]]</a>
 The class template `regex_iterator` is an iterator adaptor. It
 represents a new view of an existing iterator sequence, by enumerating
 all the occurrences of a regular expression within that sequence. A
 `regex_iterator` uses `regex_search` to find successive regular
@@ -15,11 +15,11 @@ the iterator finds and stores a value of
 reached (`regex_search` returns `false`), the iterator becomes equal to
 the end-of-sequence iterator value. The default constructor constructs
 an end-of-sequence iterator object, which is the only legitimate
 iterator to be used for the end condition. The result of `operator*` on
 an end-of-sequence iterator is not defined. For any other iterator value
-a const `match_results<BidirectionalIterator>&` is returned. The result
 of `operator->` on an end-of-sequence iterator is not defined. For any
 other iterator value a `const match_results<BidirectionalIterator>*` is
 returned. It is impossible to store things into `regex_iterator`s. Two
 end-of-sequence iterators are always equal. An end-of-sequence iterator
 is not equal to a non-end-of-sequence iterator. Two non-end-of-sequence
@@ -72,11 +72,11 @@ iterator holds a *zero-length match* if `match[0].matched == true` and
 [*Note 1*: For example, this can occur when the part of the regular
 expression that matched consists only of an assertion (such as `'^'`,
 `'$'`, `'\b'`, `'\B'`). — *end note*]
-#### Constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
 ``` cpp
 regex_iterator();
 ```
@@ -91,11 +91,11 @@ regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
 *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
 sets `pregex` to `addressof(re)`, sets `flags` to `m`, then calls
 `regex_search(begin, end, match, *pregex, flags)`. If this call returns
 `false` the constructor sets `*this` to the end-of-sequence iterator.
-#### Comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_iterator& right) const;
 ```
@@ -108,11 +108,11 @@ iterators or if the following conditions all hold:
 - `flags == right.flags`, and
 - `match[0] == right.match[0]`;
 otherwise `false`.
-#### Indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
@@ -122,11 +122,11 @@ const value_type& operator*() const;
 const value_type* operator->() const;
 ```
 *Returns:* `addressof(match)`.
-#### Increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
 ``` cpp
 regex_iterator& operator++();
 ```
@@ -156,12 +156,12 @@ If the most recent match was not a zero-length match, the operator sets
 `false` the iterator sets `*this` to the end-of-sequence iterator. The
 iterator then returns `*this`.
 In all cases in which the call to `regex_search` returns `true`,
 `match.prefix().first` shall be equal to the previous value of
-`match[0].second`, and for each index `i` in the half-open range
-`[0, match.size())` for which `match[i].matched` is `true`,
 `match.position(i)` shall return `distance(begin, match[i].first)`.
 [*Note 1*: This means that `match.position(i)` gives the offset from
 the beginning of the target sequence, which is often not the same as the
 offset from the sequence passed in the call to
@@ -183,13 +183,13 @@ regex_iterator operator++(int);
 regex_iterator tmp = *this;
 ++(*this);
 return tmp;
 ```
-### Class template `regex_token_iterator` <a id="re.tokiter">[[re.tokiter]]</a>
-#### General <a id="re.tokiter.general">[[re.tokiter.general]]</a>
 The class template `regex_token_iterator` is an iterator adaptor; that
 is to say it represents a new view of an existing iterator sequence, by
 enumerating all the occurrences of a regular expression within that
 sequence, and presenting one or more sub-expressions for each match
@@ -323,11 +323,11 @@ same as the end of the last match found, and `suffix.second` is the same
 as the end of the target sequence. — *end note*]
 The *current match* is `(*position).prefix()` if `subs[N] == -1`, or
 `(*position)[subs[N]]` for any other value of `subs[N]`.
-#### Constructors <a id="re.tokiter.cnstr">[[re.tokiter.cnstr]]</a>
 ``` cpp
 regex_token_iterator();
 ```
@@ -371,11 +371,11 @@ end-of-sequence iterator the constructor sets `result` to the address of
 the current match. Otherwise if any of the values stored in `subs` is
 equal to -1 the constructor sets `*this` to a suffix iterator that
 points to the range \[`a`, `b`), otherwise the constructor sets `*this`
 to an end-of-sequence iterator.
-#### Comparisons <a id="re.tokiter.comp">[[re.tokiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_token_iterator& right) const;
 ```
@@ -384,11 +384,11 @@ iterators, or if `*this` and `right` are both suffix iterators and
 `suffix == right.suffix`; otherwise returns `false` if `*this` or
 `right` is an end-of-sequence iterator or a suffix iterator. Otherwise
 returns `true` if `position == right.position`, `N == right.N`, and
 `subs == right.subs`. Otherwise returns `false`.
-#### Indirection <a id="re.tokiter.deref">[[re.tokiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
@@ -398,11 +398,11 @@ const value_type& operator*() const;
 const value_type* operator->() const;
 ```
 *Returns:* `result`.
-#### Increment <a id="re.tokiter.incr">[[re.tokiter.incr]]</a>
 ``` cpp
 regex_token_iterator& operator++();
 ```
@@ -424,11 +424,11 @@ Otherwise, if any of the values stored in `subs` is equal to -1 and
 iterator that points to the range \[`prev->suffix().first`,
 `prev->suffix().second`).
 Otherwise, sets `*this` to an end-of-sequence iterator.
-*Returns:* `*this`
 ``` cpp
 regex_token_iterator& operator++(int);
 ```

+### Regular expression iterators <a id="re.iter">[[re.iter]]</a>
+#### Class template `regex_iterator` <a id="re.regiter">[[re.regiter]]</a>
+##### General <a id="re.regiter.general">[[re.regiter.general]]</a>
 The class template `regex_iterator` is an iterator adaptor. It
 represents a new view of an existing iterator sequence, by enumerating
 all the occurrences of a regular expression within that sequence. A
 `regex_iterator` uses `regex_search` to find successive regular
 reached (`regex_search` returns `false`), the iterator becomes equal to
 the end-of-sequence iterator value. The default constructor constructs
 an end-of-sequence iterator object, which is the only legitimate
 iterator to be used for the end condition. The result of `operator*` on
 an end-of-sequence iterator is not defined. For any other iterator value
+a `const match_results<BidirectionalIterator>&` is returned. The result
 of `operator->` on an end-of-sequence iterator is not defined. For any
 other iterator value a `const match_results<BidirectionalIterator>*` is
 returned. It is impossible to store things into `regex_iterator`s. Two
 end-of-sequence iterators are always equal. An end-of-sequence iterator
 is not equal to a non-end-of-sequence iterator. Two non-end-of-sequence
 [*Note 1*: For example, this can occur when the part of the regular
 expression that matched consists only of an assertion (such as `'^'`,
 `'$'`, `'\b'`, `'\B'`). — *end note*]
+##### Constructors <a id="re.regiter.cnstr">[[re.regiter.cnstr]]</a>
 ``` cpp
 regex_iterator();
 ```
 *Effects:* Initializes `begin` and `end` to `a` and `b`, respectively,
 sets `pregex` to `addressof(re)`, sets `flags` to `m`, then calls
 `regex_search(begin, end, match, *pregex, flags)`. If this call returns
 `false` the constructor sets `*this` to the end-of-sequence iterator.
+##### Comparisons <a id="re.regiter.comp">[[re.regiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_iterator& right) const;
 ```
 - `flags == right.flags`, and
 - `match[0] == right.match[0]`;
 otherwise `false`.
+##### Indirection <a id="re.regiter.deref">[[re.regiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
 const value_type* operator->() const;
 ```
 *Returns:* `addressof(match)`.
+##### Increment <a id="re.regiter.incr">[[re.regiter.incr]]</a>
 ``` cpp
 regex_iterator& operator++();
 ```
 `false` the iterator sets `*this` to the end-of-sequence iterator. The
 iterator then returns `*this`.
 In all cases in which the call to `regex_search` returns `true`,
 `match.prefix().first` shall be equal to the previous value of
+`match[0].second`, and for each index `i` in the half-open range \[`0`,
+`match.size()`) for which `match[i].matched` is `true`,
 `match.position(i)` shall return `distance(begin, match[i].first)`.
 [*Note 1*: This means that `match.position(i)` gives the offset from
 the beginning of the target sequence, which is often not the same as the
 offset from the sequence passed in the call to
 regex_iterator tmp = *this;
 ++(*this);
 return tmp;
 ```
+#### Class template `regex_token_iterator` <a id="re.tokiter">[[re.tokiter]]</a>
+##### General <a id="re.tokiter.general">[[re.tokiter.general]]</a>
 The class template `regex_token_iterator` is an iterator adaptor; that
 is to say it represents a new view of an existing iterator sequence, by
 enumerating all the occurrences of a regular expression within that
 sequence, and presenting one or more sub-expressions for each match
 as the end of the target sequence. — *end note*]
 The *current match* is `(*position).prefix()` if `subs[N] == -1`, or
 `(*position)[subs[N]]` for any other value of `subs[N]`.
+##### Constructors <a id="re.tokiter.cnstr">[[re.tokiter.cnstr]]</a>
 ``` cpp
 regex_token_iterator();
 ```
 the current match. Otherwise if any of the values stored in `subs` is
 equal to -1 the constructor sets `*this` to a suffix iterator that
 points to the range \[`a`, `b`), otherwise the constructor sets `*this`
 to an end-of-sequence iterator.
+##### Comparisons <a id="re.tokiter.comp">[[re.tokiter.comp]]</a>
 ``` cpp
 bool operator==(const regex_token_iterator& right) const;
 ```
 `suffix == right.suffix`; otherwise returns `false` if `*this` or
 `right` is an end-of-sequence iterator or a suffix iterator. Otherwise
 returns `true` if `position == right.position`, `N == right.N`, and
 `subs == right.subs`. Otherwise returns `false`.
+##### Indirection <a id="re.tokiter.deref">[[re.tokiter.deref]]</a>
 ``` cpp
 const value_type& operator*() const;
 ```
 const value_type* operator->() const;
 ```
 *Returns:* `result`.
+##### Increment <a id="re.tokiter.incr">[[re.tokiter.incr]]</a>
 ``` cpp
 regex_token_iterator& operator++();
 ```
 iterator that points to the range \[`prev->suffix().first`,
 `prev->suffix().second`).
 Otherwise, sets `*this` to an end-of-sequence iterator.
+*Returns:* `*this`.
 ``` cpp
 regex_token_iterator& operator++(int);
 ```

Diff to HTML by rtfpessoa