[syncstream] - C++20 → C++23

Files changed (1) hide show

tmp/tmp5wn7kccp/{from.md → to.md} +34 -33

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

@@ -7,10 +7,15 @@
 namespace std {
   template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
     class basic_syncbuf;
   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;
@@ -66,15 +71,10 @@ namespace std {
   private:
     streambuf_type* wrapped;    // exposition only
     bool emit_on_sync{};        // exposition only
   };
-  // [syncstream.syncbuf.special], specialized algorithms
-  template<class charT, class traits, class Allocator>
-    void swap(basic_syncbuf<charT, traits, Allocator>&,
-              basic_syncbuf<charT, traits, Allocator>&);
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 known as the associated output, into internal buffers allocated using
@@ -90,28 +90,27 @@ wrapped stream buffer object.
 basic_syncbuf(streambuf_type* obuf, const Allocator& allocator);
 ```
 *Effects:* Sets `wrapped` to `obuf`.
-*Remarks:* A copy of `allocator` is used to allocate memory for internal
-buffers holding the associated output.
-*Throws:* Nothing unless an exception is thrown by the construction of a
-mutex or by memory allocation.
 *Ensures:* `get_wrapped() == obuf` and `get_allocator() == allocator`
 are `true`.
 ``` cpp
 basic_syncbuf(basic_syncbuf&& other);
 ```
 *Ensures:* The value returned by `this->get_wrapped()` is the value
 returned by `other.get_wrapped()` prior to calling this constructor.
 Output stored in `other` prior to calling this constructor will be
-stored in `*this` afterwards.
-`other.rdbuf()->pbase() == other.rdbuf()->pptr()` and
 `other.get_wrapped() == nullptr` are `true`.
 *Remarks:* This constructor disassociates `other` from its wrapped
 stream buffer, ensuring destruction of `other` produces no output.
@@ -125,34 +124,34 @@ stream buffer, ensuring destruction of `other` produces no output.
 destructor catches and ignores that exception.
 #### Assignment and swap <a id="syncstream.syncbuf.assign">[[syncstream.syncbuf.assign]]</a>
 ``` cpp
-basic_syncbuf& operator=(basic_syncbuf&& rhs) noexcept;
 ```
 *Effects:* Calls `emit()` then move assigns from `rhs`. After the move
 assignment `*this` has the observable state it would have had if it had
 been move constructed from `rhs` [[syncstream.syncbuf.cons]].
-*Returns:* `*this`.
 *Ensures:*
 - `rhs.get_wrapped() == nullptr` is `true`.
 - `this->get_allocator() == rhs.get_allocator()` is `true` when
   ``` cpp
   allocator_traits<Allocator>::propagate_on_container_move_assignment::value
   ```
   is `true`; otherwise, the allocator is unchanged.
 *Remarks:* This assignment operator disassociates `rhs` from its wrapped
 stream buffer, ensuring destruction of `rhs` produces no output.
 ``` cpp
-void swap(basic_syncbuf& other) noexcept;
 ```
 *Preconditions:* Either
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
 `true` or `this->get_allocator() == other.get_allocator()` is `true`.
@@ -169,25 +168,25 @@ bool emit();
 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.
 *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.
-*Ensures:* On success, the associated output is empty.
-*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()`
-call synchronizes with subsequent `emit()` calls in that total order.
 *Remarks:* May call member functions of `wrapped` while holding a lock
 uniquely associated with `wrapped`.
 ``` cpp
 streambuf_type* get_wrapped() const noexcept;
@@ -226,11 +225,11 @@ otherwise `0`.
 #### Specialized algorithms <a id="syncstream.syncbuf.special">[[syncstream.syncbuf.special]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_syncbuf<charT, traits, Allocator>& a,
-            basic_syncbuf<charT, traits, Allocator>& b) noexcept;
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ### Class template `basic_osyncstream` <a id="syncstream.osyncstream">[[syncstream.osyncstream]]</a>
@@ -262,11 +261,11 @@ namespace std {
       : basic_osyncstream(os, Allocator()) {}
     basic_osyncstream(basic_osyncstream&&) noexcept;
     ~basic_osyncstream();
     // assignment
-    basic_osyncstream& operator=(basic_osyncstream&&) noexcept;
     // [syncstream.osyncstream.members], member functions
     void emit();
     streambuf_type* get_wrapped() const noexcept;
     syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
@@ -275,12 +274,12 @@ namespace std {
     syncbuf_type sb;    // exposition only
   };
 }
 ```
-`Allocator` shall meet the *Cpp17Allocator* requirements (
-[[cpp17.allocator]]).
 [*Example 1*:
 A named variable can be used within a block statement for streaming.
@@ -315,13 +314,13 @@ 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 might be
-called from `emit()` while a lock is held. Care should be taken to
-ensure that this does not result in deadlock. — *end note*]
 *Ensures:* `get_wrapped() == buf` is `true`.
 ``` cpp
 basic_osyncstream(basic_osyncstream&& other) noexcept;
@@ -330,20 +329,22 @@ 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 `os.get_wrapped()` prior to calling this constructor.
 `nullptr == other.get_wrapped()` is `true`.
 #### Member functions <a id="syncstream.osyncstream.members">[[syncstream.osyncstream.members]]</a>
 ``` cpp
 void emit();
 ```
-*Effects:* 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:

 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>
+    void swap(basic_syncbuf<charT, traits, Allocator>&,
+              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;
   private:
     streambuf_type* wrapped;    // exposition only
     bool emit_on_sync{};        // exposition only
   };
 }
 ```
 Class template `basic_syncbuf` stores character data written to it,
 known as the associated output, into internal buffers allocated using
 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
+mutex or by memory allocation.
+*Remarks:* A copy of `allocator` is used to allocate memory for internal
+buffers holding the associated output.
 ``` cpp
 basic_syncbuf(basic_syncbuf&& other);
 ```
 *Ensures:* The value returned by `this->get_wrapped()` is the value
 returned by `other.get_wrapped()` prior to calling this constructor.
 Output stored in `other` prior to calling this constructor will be
+stored in `*this` afterwards. `other.pbase() == other.pptr()` and
 `other.get_wrapped() == nullptr` are `true`.
 *Remarks:* This constructor disassociates `other` from its wrapped
 stream buffer, ensuring destruction of `other` produces no output.
 destructor catches and ignores that exception.
 #### Assignment and swap <a id="syncstream.syncbuf.assign">[[syncstream.syncbuf.assign]]</a>
 ``` cpp
+basic_syncbuf& operator=(basic_syncbuf&& rhs);
 ```
 *Effects:* Calls `emit()` then move assigns from `rhs`. After the move
 assignment `*this` has the observable state it would have had if it had
 been move constructed from `rhs` [[syncstream.syncbuf.cons]].
 *Ensures:*
 - `rhs.get_wrapped() == nullptr` is `true`.
 - `this->get_allocator() == rhs.get_allocator()` is `true` when
   ``` cpp
   allocator_traits<Allocator>::propagate_on_container_move_assignment::value
   ```
   is `true`; otherwise, the allocator is unchanged.
+*Returns:* `*this`.
 *Remarks:* This assignment operator disassociates `rhs` from its wrapped
 stream buffer, ensuring destruction of `rhs` produces no output.
 ``` cpp
+void swap(basic_syncbuf& other);
 ```
 *Preconditions:* Either
 `allocator_traits<Allocator>::propagate_on_container_swap::value` is
 `true` or `this->get_allocator() == other.get_allocator()` is `true`.
 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()`
+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;
 #### Specialized algorithms <a id="syncstream.syncbuf.special">[[syncstream.syncbuf.special]]</a>
 ``` cpp
 template<class charT, class traits, class Allocator>
   void swap(basic_syncbuf<charT, traits, Allocator>& a,
+            basic_syncbuf<charT, traits, Allocator>& b);
 ```
 *Effects:* Equivalent to `a.swap(b)`.
 ### Class template `basic_osyncstream` <a id="syncstream.osyncstream">[[syncstream.osyncstream]]</a>
       : basic_osyncstream(os, Allocator()) {}
     basic_osyncstream(basic_osyncstream&&) noexcept;
     ~basic_osyncstream();
     // assignment
+    basic_osyncstream& operator=(basic_osyncstream&&);
     // [syncstream.osyncstream.members], member functions
     void emit();
     streambuf_type* get_wrapped() const noexcept;
     syncbuf_type* rdbuf() const noexcept { return const_cast<syncbuf_type*>(addressof(sb)); }
     syncbuf_type sb;    // exposition only
   };
 }
 ```
+`Allocator` shall meet the *Cpp17Allocator* requirements
+[[allocator.requirements.general]].
 [*Example 1*:
 A named variable can be used within a block statement for streaming.
 ```
 *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*]
 *Ensures:* `get_wrapped() == buf` is `true`.
 ``` 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`.
 #### Member functions <a id="syncstream.osyncstream.members">[[syncstream.osyncstream.members]]</a>
 ``` cpp
 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:

Diff to HTML by rtfpessoa