[re.submatch] - C++14 → C++17

Files changed (1) hide show

tmp/tmpgsi4q6be/{from.md → to.md} +79 -69

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

@@ -4,18 +4,18 @@ Class template `sub_match` denotes the sequence of characters matched by
 a particular marked sub-expression.
 ``` cpp
 namespace std {
   template <class BidirectionalIterator>
- class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> {
     public:
-     typedef typename iterator_traits<BidirectionalIterator>::
- value_type                                               value_type;
-     typedef typename iterator_traits<BidirectionalIterator>::
- difference_type                                          difference_type;
-     typedef BidirectionalIterator                              iterator;
- typedef basic_string<value_type>                           string_type;
       bool matched;
       constexpr sub_match();
@@ -41,23 +41,23 @@ member `matched`.
 ``` cpp
 difference_type length() const;
 ```
-*Returns:* `(matched ? distance(first, second) : 0)`.
 ``` cpp
 operator string_type() const;
 ```
-*Returns:* `matched ? string_type(first, second) : string_type()`.
 ``` cpp
 string_type str() const;
 ```
-*Returns:* `matched ? string_type(first, second) : string_type()`.
 ``` cpp
 int compare(const sub_match& s) const;
 ```
@@ -120,320 +120,330 @@ template <class BiIter>
 *Returns:* `lhs.compare(rhs) > 0`.
 ``` cpp
 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:* `rhs.compare(lhs.c_str()) == 0`.
 ``` cpp
 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)`.
 ``` cpp
 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:* `rhs.compare(lhs.c_str()) > 0`.
 ``` cpp
 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:* `rhs < lhs`.
 ``` cpp
 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)`.
 ``` cpp
 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:* `!(rhs < lhs)`.
 ``` cpp
 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);
 ```
-*Returns:* `lhs.compare(rhs.c_str()) == 0`.
 ``` cpp
 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);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 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);
 ```
-*Returns:* `lhs.compare(rhs.c_str()) < 0`.
 ``` cpp
 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);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 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);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 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);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator==(typename iterator_traits<BiIter>::value_type const* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs.compare(lhs) == 0`.
 ``` cpp
 template <class BiIter>
-  bool operator!=(typename iterator_traits<BiIter>::value_type const* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator<(typename iterator_traits<BiIter>::value_type const* lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs.compare(lhs) > 0`.
 ``` cpp
 template <class BiIter>
-  bool operator>(typename iterator_traits<BiIter>::value_type const* lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
-  bool operator>=(typename iterator_traits<BiIter>::value_type const* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator<=(typename iterator_traits<BiIter>::value_type const* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template <class BiIter>
   bool operator!=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<(const sub_match<BiIter>& lhs,
-                 typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `lhs.compare(rhs) < 0`.
 ``` cpp
 template <class BiIter>
   bool operator>(const sub_match<BiIter>& lhs,
-                 typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
   bool operator>=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const* rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator==(typename iterator_traits<BiIter>::value_type const& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:*
 `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0`.
 ``` cpp
 template <class BiIter>
-  bool operator!=(typename iterator_traits<BiIter>::value_type const& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator<(typename iterator_traits<BiIter>::value_type const& lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:*
 `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0`.
 ``` cpp
 template <class BiIter>
-  bool operator>(typename iterator_traits<BiIter>::value_type const& lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
-  bool operator>=(typename iterator_traits<BiIter>::value_type const& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
-  bool operator<=(typename iterator_traits<BiIter>::value_type const& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
 ``` cpp
 template <class BiIter>
   bool operator!=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<(const sub_match<BiIter>& lhs,
-                 typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0`.
 ``` cpp
 template <class BiIter>
   bool operator>(const sub_match<BiIter>& lhs,
-                 typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
   bool operator>=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<=(const sub_match<BiIter>& lhs,
-                  typename iterator_traits<BiIter>::value_type const& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class charT, class ST, class BiIter>
   basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 ```
-*Returns:* `(os << m.str())`.

 a particular marked sub-expression.
 ``` cpp
 namespace std {
   template <class BidirectionalIterator>
+ class sub_match : public pair<BidirectionalIterator, BidirectionalIterator> {
     public:
+      using value_type      =
+              typename iterator_traits<BidirectionalIterator>::value_type;
+      using difference_type =
+              typename iterator_traits<BidirectionalIterator>::difference_type;
+      using iterator        = BidirectionalIterator;
+      using string_type = basic_string<value_type>;
       bool matched;
       constexpr sub_match();
 ``` cpp
 difference_type length() const;
 ```
+*Returns:* `matched ? distance(first, second) : 0`.
 ``` cpp
 operator string_type() const;
 ```
+*Returns:* `matched ? string_type(first, second) : string_type()`.
 ``` cpp
 string_type str() const;
 ```
+*Returns:* `matched ? string_type(first, second) : string_type()`.
 ``` cpp
 int compare(const sub_match& s) const;
 ```
 *Returns:* `lhs.compare(rhs) > 0`.
 ``` cpp
 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:*
+``` cpp
+rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) == 0
+```
 ``` cpp
 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)`.
 ``` cpp
 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:*
+``` cpp
+rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) > 0
+```
 ``` cpp
 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:* `rhs < lhs`.
 ``` cpp
 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)`.
 ``` cpp
 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:* `!(rhs < lhs)`.
 ``` cpp
 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);
 ```
+*Returns:*
+``` cpp
+lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
+```
 ``` cpp
 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);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 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);
 ```
+*Returns:*
+``` cpp
+lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) < 0
+```
 ``` cpp
 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);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 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);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 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);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs.compare(lhs) == 0`.
 ``` cpp
 template <class BiIter>
+  bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs.compare(lhs) > 0`.
 ``` cpp
 template <class BiIter>
+  bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
+  bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `lhs.compare(rhs) == 0`.
 ``` cpp
 template <class BiIter>
   bool operator!=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `lhs.compare(rhs) < 0`.
 ``` cpp
 template <class BiIter>
   bool operator>(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
   bool operator>=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type* rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:*
 `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0`.
 ``` cpp
 template <class BiIter>
+  bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:*
 `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0`.
 ``` cpp
 template <class BiIter>
+  bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
                  const sub_match<BiIter>& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
+  bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
+  bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
                   const sub_match<BiIter>& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class BiIter>
   bool operator==(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
 ``` cpp
 template <class BiIter>
   bool operator!=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:* `!(lhs == rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:*
 `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0`.
 ``` cpp
 template <class BiIter>
   bool operator>(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:* `rhs < lhs`.
 ``` cpp
 template <class BiIter>
   bool operator>=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:* `!(lhs < rhs)`.
 ``` cpp
 template <class BiIter>
   bool operator<=(const sub_match<BiIter>& lhs,
+ const typename iterator_traits<BiIter>::value_type& rhs);
 ```
 *Returns:* `!(rhs < lhs)`.
 ``` cpp
 template <class charT, class ST, class BiIter>
   basic_ostream<charT, ST>&
     operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 ```
+*Returns:* `os << m.str()`.

Diff to HTML by rtfpessoa