[fs.path.member] - C++20 → C++23

Files changed (1) hide show

tmp/tmpbaq6s1ca/{from.md → to.md} +15 -19

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

@@ -226,12 +226,12 @@ template<class Source>
 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
-[*Note 2*: This directly manipulates the value of `native()` and may
-not be portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
@@ -380,14 +380,10 @@ const value_type* c_str() const noexcept;
 operator string_type() const;
 ```
 *Returns:* `native()`.
-[*Note 3*: Conversion to `string_type` is provided so that an object of
-class `path` can be given as an argument to existing standard library
-file stream constructors and open functions. — *end note*]
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
@@ -587,17 +583,17 @@ path(".bar").extension();               // yields "" and stem() is ".bar"
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
-[*Note 4*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
-[*Note 5*: On non-POSIX operating systems, for a path `p`, it may not
-be the case that `p.stem() + p.extension() == p.filename()`, even though
-the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
@@ -696,25 +692,21 @@ slashes, but that does not affect `path` equality.
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
-*Returns:* `*this` made relative to `base`. Does not
-resolve [[fs.class.path]] symlinks. Does not first
-normalize [[fs.path.generic]] `*this` or `base`.
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
-[*Note 6*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
@@ -732,10 +724,14 @@ Then,
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
@@ -749,26 +745,26 @@ The above assertions will succeed. On Windows, the returned path’s
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
-[*Note 7*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
-[*Note 8*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
-[*Note 9*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
-[*Note 10*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]

 ```
 *Effects:* Appends `path(x).native()` to the pathname in the native
 format.
+[*Note 2*: This directly manipulates the value of `native()`, which is
+not necessarily portable between operating systems. — *end note*]
 *Returns:* `*this`.
 ``` cpp
 path& operator+=(value_type x);
 operator string_type() const;
 ```
 *Returns:* `native()`.
 ``` cpp
 template<class EcharT, class traits = char_traits<EcharT>,
          class Allocator = allocator<EcharT>>
   basic_string<EcharT, traits, Allocator>
     string(const Allocator& a = Allocator()) const;
 path("..bar").extension();              // yields ".bar" and stem() is "."
 ```
 — *end example*]
+[*Note 3*: The period is included in the return value so that it is
 possible to distinguish between no extension and an empty
 extension. — *end note*]
+[*Note 4*: On non-POSIX operating systems, for a path `p`, it is
+possible that `p.stem() + p.extension() == p.filename()` is `false`,
+even though the generic format pathnames are the same. — *end note*]
 ##### Query <a id="fs.path.query">[[fs.path.query]]</a>
 ``` cpp
 [[nodiscard]] bool empty() const noexcept;
 ``` cpp
 path lexically_relative(const path& base) const;
 ```
 *Effects:* If:
 - `root_name() != base.root_name()` is `true`, or
 - `is_absolute() != base.is_absolute()` is `true`, or
 - `!has_root_directory() && base.has_root_directory()` is `true`, or
 - any *filename* in `relative_path()` or `base.relative_path()` can be
   interpreted as a *root-name*,
 returns `path()`.
+[*Note 5*: On a POSIX implementation, no *filename* in a
 *relative-path* is acceptable as a *root-name*. — *end note*]
 Determines the first mismatched element of `*this` and `base` as if by:
 ``` cpp
 - returns an object of class `path` that is default-constructed,
   followed by
   - application of `operator/=(path(".."))` `n` times, and then
   - application of `operator/=` for each element in \[`a`, `end()`).
+*Returns:* `*this` made relative to `base`. Does not
+resolve [[fs.class.path]] symlinks. Does not first
+normalize [[fs.path.generic]] `*this` or `base`.
 [*Example 11*:
 ``` cpp
 assert(path("/a/d").lexically_relative("/a/b/c") == "../../d");
 assert(path("/a/b/c").lexically_relative("/a/d") == "../b/c");
 *directory-separator* characters will be backslashes rather than
 slashes, but that does not affect `path` equality.
 — *end example*]
+[*Note 6*: If symlink following semantics are desired, use the
 operational function `relative()`. — *end note*]
+[*Note 7*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]
 ``` cpp
 path lexically_proximate(const path& base) const;
 ```
 *Returns:* If the value of `lexically_relative(base)` is not an empty
 path, return it. Otherwise return `*this`.
+[*Note 8*: If symlink following semantics are desired, use the
 operational function `proximate()`. — *end note*]
+[*Note 9*: If normalization [[fs.path.generic]] is needed to ensure
 consistent matching of elements, apply `lexically_normal()` to `*this`,
 `base`, or both. — *end note*]

Diff to HTML by rtfpessoa