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

Files changed (1) hide show

tmp/tmp0n9_44pd/{from.md → to.md} +19 -25

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

@@ -41,15 +41,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
@@ -65,28 +60,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.
@@ -100,34 +94,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`.
@@ -144,25 +138,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;
@@ -201,10 +195,10 @@ 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)`.

   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)`.

Diff to HTML by rtfpessoa