[syncstream] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp89x81lgk/{from.md → to.md} +27 -25

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

@@ -4,10 +4,11 @@
 ``` cpp
 #include <ostream>  // see [ostream.syn]
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
   // [syncstream.syncbuf.special], specialized algorithms
   template<class charT, class traits, class Allocator>
@@ -15,10 +16,11 @@ namespace std {
               basic_syncbuf<charT, traits, Allocator>&);
   using syncbuf = basic_syncbuf<char>;
   using wsyncbuf = basic_syncbuf<wchar_t>;
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
   using osyncstream = basic_osyncstream<char>;
   using wosyncstream = basic_osyncstream<wchar_t>;
@@ -36,13 +38,13 @@ agents writing to the same stream.
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_syncbuf : public basic_streambuf<charT, traits> {
   public:
     using char_type      = charT;
-    using int_type       = typename traits::int_type;
-    using pos_type       = typename traits::pos_type;
-    using off_type       = typename traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
@@ -69,11 +71,11 @@ namespace std {
     // [syncstream.syncbuf.virtuals], overridden virtual functions
     int sync() override;
   private:
     streambuf_type* wrapped;    // exposition only
-    bool emit_on_sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
@@ -88,11 +90,11 @@ wrapped stream buffer object.
 ``` cpp
 basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
 ```
-*Effects:* Sets `wrapped` to `obuf`.
 *Ensures:* `get_wrapped() == obuf` and `get_allocator() == allocator`
 are `true`.
 *Throws:* Nothing unless an exception is thrown by the construction of a
@@ -163,13 +165,13 @@ void swap(basic_syncbuf& other);
 ``` cpp
 bool emit();
 ```
 *Effects:* Atomically transfers the associated output of `*this` to the
-stream buffer `*wrapped`, so that it appears in the output stream as a
-contiguous sequence of characters. `wrapped->pubsync()` is called if and
-only if a call was made to `sync()` since the most recent call to
 `emit()`, if any.
 *Synchronization:* All `emit()` calls transferring characters to the
 same stream buffer object appear to execute in a total order consistent
 with the “happens before” relation [[intro.races]], where each `emit()`
@@ -178,23 +180,23 @@ call synchronizes with subsequent `emit()` calls in that total order.
 *Ensures:* On success, the associated output is empty.
 *Returns:* `true` if all of the following conditions hold; otherwise
 `false`:
-- `wrapped == nullptr` is `false`.
 - All of the characters in the associated output were successfully
   transferred.
-- The call to `wrapped->pubsync()` (if any) succeeded.
-*Remarks:* May call member functions of `wrapped` while holding a lock
-uniquely associated with `wrapped`.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
-*Returns:* `wrapped`.
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
@@ -203,22 +205,22 @@ assignment operator.
 ``` cpp
 void set_emit_on_sync(bool b) noexcept;
 ```
-*Effects:* `emit_on_sync = b`.
 #### Overridden virtual functions <a id="syncstream.syncbuf.virtuals">[[syncstream.syncbuf.virtuals]]</a>
 ``` cpp
 int sync() override;
 ```
 *Effects:* Records that the wrapped stream buffer is to be flushed.
-Then, if `emit_on_sync` is `true`, calls `emit()`.
-[*Note 1*: If `emit_on_sync` is `false`, the actual flush is delayed
 until a call to `emit()`. — *end note*]
 *Returns:* If `emit()` was called and returned `false`, returns `-1`;
 otherwise `0`.
@@ -240,13 +242,13 @@ template<class charT, class traits, class Allocator>
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_osyncstream : public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
-    using int_type    = typename traits::int_type;
-    using pos_type    = typename traits::pos_type;
-    using off_type    = typename traits::off_type;
     using traits_type = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
@@ -311,12 +313,12 @@ In this example, `cout` is not flushed.
 ``` cpp
 basic_osyncstream(streambuf_type* buf, const Allocator& allocator);
 ```
-*Effects:* Initializes `sb` from `buf` and `allocator`. Initializes the
-base class with `basic_ostream<charT, traits>(addressof(sb))`.
 [*Note 1*: The member functions of the provided stream buffer can be
 called from `emit()` while a lock is held, which might result in a
 deadlock if used incautiously. — *end note*]
@@ -324,13 +326,13 @@ deadlock if used incautiously. — *end note*]
 ``` cpp
 basic_osyncstream(basic_osyncstream&& other) noexcept;
 ```
-*Effects:* Move constructs the base class and `sb` from the
 corresponding subobjects of `other`, and calls
-`basic_ostream<charT, traits>::set_rdbuf(addressof(sb))`.
 *Ensures:* The value returned by `get_wrapped()` is the value returned
 by `other.get_wrapped()` prior to calling this constructor.
 `nullptr == other.get_wrapped()` is `true`.
@@ -340,11 +342,11 @@ by `other.get_wrapped()` prior to calling this constructor.
 void emit();
 ```
 *Effects:* Behaves as an unformatted output
 function [[ostream.unformatted]]. After constructing a `sentry` object,
-calls `sb.emit()`. If that call returns `false`, calls
 `setstate(ios_base::badbit)`.
 [*Example 1*:
 A flush on a `basic_osyncstream` does not flush immediately:
@@ -383,11 +385,11 @@ on the underlying stream.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
-*Returns:* `sb.get_wrapped()`.
 [*Example 3*:
 Obtaining the wrapped stream buffer with `get_wrapped()` allows wrapping
 it again with an `osyncstream`. For example,

 ``` cpp
 #include <ostream>  // see [ostream.syn]
 namespace std {
+  // [syncstream.syncbuf], class template basic_syncbuf
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
   // [syncstream.syncbuf.special], specialized algorithms
   template<class charT, class traits, class Allocator>
               basic_syncbuf<charT, traits, Allocator>&);
   using syncbuf = basic_syncbuf<char>;
   using wsyncbuf = basic_syncbuf<wchar_t>;
+  // [syncstream.osyncstream], class template basic_osyncstream
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_osyncstream;
   using osyncstream = basic_osyncstream<char>;
   using wosyncstream = basic_osyncstream<wchar_t>;
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_syncbuf : public basic_streambuf<charT, traits> {
   public:
     using char_type      = charT;
+    using int_type       = traits::int_type;
+    using pos_type       = traits::pos_type;
+    using off_type       = traits::off_type;
     using traits_type    = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     // [syncstream.syncbuf.virtuals], overridden virtual functions
     int sync() override;
   private:
     streambuf_type* wrapped;    // exposition only
+    bool emit-on-sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 ``` cpp
 basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
 ```
+*Effects:* Sets *wrapped* to `obuf`.
 *Ensures:* `get_wrapped() == obuf` and `get_allocator() == allocator`
 are `true`.
 *Throws:* Nothing unless an exception is thrown by the construction of a
 ``` cpp
 bool emit();
 ```
 *Effects:* Atomically transfers the associated output of `*this` to the
+stream buffer `*`*`wrapped`*, so that it appears in the output stream as
+a contiguous sequence of characters. *`wrapped`*`->pubsync()` is called
+if and only if a call was made to `sync()` since the most recent call to
 `emit()`, if any.
 *Synchronization:* All `emit()` calls transferring characters to the
 same stream buffer object appear to execute in a total order consistent
 with the “happens before” relation [[intro.races]], where each `emit()`
 *Ensures:* On success, the associated output is empty.
 *Returns:* `true` if all of the following conditions hold; otherwise
 `false`:
+- *`wrapped`*` == nullptr` is `false`.
 - All of the characters in the associated output were successfully
   transferred.
+- The call to *`wrapped`*`->pubsync()` (if any) succeeded.
+*Remarks:* May call member functions of *wrapped* while holding a lock
+uniquely associated with *wrapped*.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
+*Returns:* *wrapped*.
 ``` cpp
 allocator_type get_allocator() const noexcept;
 ```
 ``` cpp
 void set_emit_on_sync(bool b) noexcept;
 ```
+*Effects:* *`emit-on-sync`*` = b`.
 #### Overridden virtual functions <a id="syncstream.syncbuf.virtuals">[[syncstream.syncbuf.virtuals]]</a>
 ``` cpp
 int sync() override;
 ```
 *Effects:* Records that the wrapped stream buffer is to be flushed.
+Then, if *emit-on-sync* is `true`, calls `emit()`.
+[*Note 1*: If *emit-on-sync* is `false`, the actual flush is delayed
 until a call to `emit()`. — *end note*]
 *Returns:* If `emit()` was called and returned `false`, returns `-1`;
 otherwise `0`.
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
   class basic_osyncstream : public basic_ostream<charT, traits> {
   public:
     using char_type   = charT;
+    using int_type    = traits::int_type;
+    using pos_type    = traits::pos_type;
+    using off_type    = traits::off_type;
     using traits_type = traits;
     using allocator_type = Allocator;
     using streambuf_type = basic_streambuf<charT, traits>;
     using syncbuf_type   = basic_syncbuf<charT, traits, Allocator>;
 ``` cpp
 basic_osyncstream(streambuf_type* buf, const Allocator& allocator);
 ```
+*Effects:* Initializes *sb* from `buf` and `allocator`. Initializes the
+base class with `basic_ostream<charT, traits>(addressof(`*`sb`*`))`.
 [*Note 1*: The member functions of the provided stream buffer can be
 called from `emit()` while a lock is held, which might result in a
 deadlock if used incautiously. — *end note*]
 ``` cpp
 basic_osyncstream(basic_osyncstream&& other) noexcept;
 ```
+*Effects:* Move constructs the base class and *sb* from the
 corresponding subobjects of `other`, and calls
+`basic_ostream<charT, traits>::set_rdbuf(addressof(`*`sb`*`))`.
 *Ensures:* The value returned by `get_wrapped()` is the value returned
 by `other.get_wrapped()` prior to calling this constructor.
 `nullptr == other.get_wrapped()` is `true`.
 void emit();
 ```
 *Effects:* Behaves as an unformatted output
 function [[ostream.unformatted]]. After constructing a `sentry` object,
+calls *`sb`*`.emit()`. If that call returns `false`, calls
 `setstate(ios_base::badbit)`.
 [*Example 1*:
 A flush on a `basic_osyncstream` does not flush immediately:
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
 ```
+*Returns:* *`sb`*`.get_wrapped()`.
 [*Example 3*:
 Obtaining the wrapped stream buffer with `get_wrapped()` allows wrapping
 it again with an `osyncstream`. For example,

Diff to HTML by rtfpessoa