<html>
<head>
<title>Networking TS enhancement to enable custom I/O executors</title>
<style>
ins {color:#00A000}
ins p code {color:#00A000}
p ins code {color:#00A000}
del {color:#A00000}
del p code {color:#A00000}
p del code {color:#A00000}

.changed {
  border-right: 0.5em solid #4040d0;
  background-color: #f0f0ff;
}

pre .changed {
  display:inline-block;
  width:100%;
}

blockquote {border-left:0.4em solid #C0C0C0; padding-left:0.2em}
table, th, td {border:1px solid #C0C0C0}

div.wording {
  margin-left: 5em;
  margin-right: 5em;
  font-family: serif;
  hyphens: auto;
  line-height: 1.35;
  text-align: justify;
}

div.wording div.wording {
  margin-left: 0em;
  margin-right: 0em;
}

div.wording ul {
  list-style-type: none;
  padding-left: 2em;
  margin-top: -0.2em;
  margin-bottom: -0.2em;
}

div.wording a { text-decoration: none; }

div.wording a.hidden_link {
  text-decoration: none;
  color: inherit;
}

div.wording li {
  margin-top: 0.6em;
  margin-bottom: 0.6em;
}

div.wording h1 { line-height: 1; }
div.wording h2 { line-height: 1; }
div.wording h3 { line-height: 1; }
div.wording h4 { line-height: 1; }

div.wording ul > li:before {
  content: "\2014";
  position: absolute;
  margin-left: -1.5em;
}

.abbr_ref { float: right; }
.folded_abbr_ref { float: right; }
.unfolded_abbr_ref { display: none; }

.secnum { display: inline-block; min-width: 35pt; }
.annexnum { display: block; }

div.wording div.sourceLinkParent {
  float: right;
}

div.wording a.sourceLink {
  position: absolute;
  opacity: 0;
  margin-left: 10pt;
}

div.wording a.sourceLink:hover {
  opacity: 1;
}

div.wording a.itemDeclLink {
  position: absolute;
  font-size: 75%;
  text-align: right;
  width: 5em;
  opacity: 0;
}
div.wording a.itemDeclLink:hover { opacity: 1; }

div.wording div.marginalizedparent {
  position: relative;
  left: -5em;
}

div.wording div.footnoteNumberParent {
  position: relative;
  left: -4.7em;
}

div.wording a.marginalized {
  position: absolute;
  font-size: 75%;
  text-align: right;
  width: 5em;
}

div.wording a.enumerated_item_num {
  position: relative;
  left: -3.5em;
  display: inline-block;
  margin-right: -3em;
  text-align: right;
  width: 3em;
}

div.wording div.para { margin-bottom: 0.6em; margin-top: 0.6em; text-align: justify; }
div.wording div.sentence { display: inline; }

div.wording span.indexparent {
  display: inline;
  position: relative;
  float: right;
  right: -1em;
}

div.wording a.index {
  position: absolute;
  display: none;
}

div.wording a.index:before { content: "⟵"; }
  /* this way the content is not selectable */

div.wording a.index:target {
  display: inline;
}

.indexitems {
  margin-left: 2em;
  text-indent: -2em;
}

div.wording div.itemdescr {
  margin-left: 3em;
}

.bnf {
  font-family: sans-serif;
  font-style: italic;
  margin-left: 40pt;
  margin-top: 0.5em;
  margin-bottom: 0.5em;
}

.ncbnf {
  font-family: sans-serif;
  font-style: italic;
  margin-top: 0.5em;
  margin-bottom: 0.5em;
  margin-left: 40pt;
}

.ncrebnf {
  font-family: serif;
  font-style: italic;
  margin-top: 0.5em;
  margin-bottom: 0.5em;
  margin-left: 40pt;
}

.ncsimplebnf {
  font-family: serif;
  font-style: italic;
  margin-top: 0.5em;
  margin-bottom: 0.5em;
  margin-left: 40pt;
  background: inherit; /* no idea why this doesn't appear to be the default */
}

div.wording span.textnormal {
  font-style: normal;
  font-family: serif;
  white-space: normal;
  display: inline-block;
}

div.wording span.rlap {
    display: inline-block;
    width: 0px;
}

div.wording span.descr { font-style: normal; font-family: serif; }
.grammarterm { font-style: italic; font-family: sans-serif; }
.ncrebnf .grammarterm { font-style: italic; font-family: serif; }
div.wording span.term { font-style: italic; }
div.wording span.terminal { font-family: monospace; font-style: normal; }
div.wording span.tcode { font-family: monospace; font-style: normal; }
div.wording span.textbf { font-weight: bold; }
div.wording span.textsf { font-family: sans-serif; }
div.wording span.textsc { font-variant: small-caps; }
div.wording a.nontermdef { font-style: italic; font-family: sans-serif; }
.ncrebnf a.nontermdef { font-style: italic; font-family: serif; }
div.wording span.emph { font-style: italic; }
div.wording span.techterm { font-style: italic; }
div.wording span.mathit { font-style: italic; }
div.wording span.mathsf { font-family: sans-serif; }
div.wording span.mathrm { font-family: serif; font-style: normal; }
div.wording span.textrm { font-family: serif; }
div.wording span.textsl { font-style: italic; }
div.wording span.mathtt { font-family: monospace; font-style: normal; }
div.wording span.mbox { font-family: serif; font-style: normal; }
div.wording span.ungap { display: inline-block; width: 2pt; }
div.wording span.textit { font-style: italic; }
div.wording span.texttt { font-family: monospace; }
div.wording span.tcode_in_codeblock { font-family: monospace; font-style: normal; }

div.wording span.phantom { color: white; }
  /* Unfortunately, this way the text is still selectable. Another
  option is display:none, but then we lose the nice layout.
  Todo: find proper solution. */

div.wording span.math { font-style: normal; }

div.wording span.mathblock {
  display: block;
  margin-left: auto;
  margin-right: auto;
  margin-top: 1.2em;
  margin-bottom: 1.2em;
  text-align: center;
}

div.wording span.mathalpha {
  font-style: italic;
}

div.wording span.synopsis {
  font-weight: bold;
  margin-top: 0.5em;
  display: block;
}

div.wording span.definition {
  font-weight: bold;
  display: block;
}

.codeblock {
  margin-left: 1.2em;
  line-height: 127%;
}

.outputblock {
  margin-left: 1.2em;
  line-height: 127%;
}

div.wording code {
  font-family: monospace;
  font-style: normal;
}

div.wording div.itemdecl {
  margin-top: 2ex;
}

code.itemdeclcode {
  white-space: pre;
  display: block;
}

div.wording span.comment { color: #404040; font-style: italic; font-family: serif; }
div.wording span.keyword { color: #00607c; font-style: normal; }
div.wording span.parenthesis { color: #af1915; }
div.wording span.curlybracket { color: #af1915; }
div.wording span.squarebracket { color: #af1915; }
div.wording span.literal { color: #9F6807; }
div.wording span.operator { color: #570057; }
div.wording span.anglebracket { color: #570057; }
div.wording span.preprocessordirective { color: #6F4E37; }

div.wording span.textsuperscript {
  vertical-align: super;
  font-size: smaller;
  line-height: 0;
}

.footnotenum { vertical-align: super; font-size: smaller; line-height: 0; }

.footnote {
  font-size: small;
  margin-left: 2em;
  margin-right: 2em;
  margin-top: 0.6em;
  margin-bottom: 0.6em;
}

div.wording div.minipage {
  display: inline-block;
  margin-right: 3em;
}

div.wording div.numberedTable {
  text-align: center;
  margin: 2em;
}

div.wording div.figure {
  text-align: center;
  margin: 2em;
}

div.wording table {
  border: 1px solid black;
  border-collapse: collapse;
  margin-left: auto;
  margin-right: auto;
  margin-top: 0.8em;
  text-align: left;
  hyphens: none; /* otherwise some columns get very narrow, e.g. [tab:hash] */
}

div.wording td, th {
  padding-left: 1em;
  padding-right: 1em;
  vertical-align: top;
}

div.wording td.empty {
    padding: 0px;
    padding-left: 1px;
}

div.wording td.left {
  text-align: left;
}

div.wording td.right {
  text-align: right;
}

div.wording td.center {
  text-align: center;
}

div.wording td.justify {
  text-align: justify;
}

div.wording td.border {
  border-left: 1px solid black;
}

div.wording tr.rowsep, td.cline {
  border-top: 1px solid black;
}

div.wording tr.capsep {
  border-top: 3px solid black;
  border-top-style: double;
}

div.wording th {
  border-bottom: 1px solid black;
}

div.wording span.centry {
  font-weight: bold;
}

div.wording div.table {
  display: block;
  margin-left: auto;
  margin-right: auto;
  text-align: center;
  width: 90%;
}

div.wording span.indented {
  background: inherit;
  display: block;
  margin-left: 2em;
  margin-bottom: 1em;
  margin-top: 1em;
}

div.wording ol.enumeratea { list-style-type: none; background: inherit; }
div.wording ol.enumerate { list-style-type: none; background: inherit; }

div.wording ins { text-decoration: underline; color: green; }
div.wording del { text-decoration: line-through; color: red; }

div.wording .noteBody { display: inline; }
div.wording .note { display: inline; }
</style>
</head>
<body>

<pre>
Document number: P1322R3
Date:            2021-02-05
Project:         Programming Language C++
Audience:        SG4 - Networking, LEWG
Reply-to:        Christopher Kohlhoff &lt;chris&#x40;kohlhoff.com&gt;
</pre>

<h1>Networking TS enhancement to enable custom I/O executors</h1>

<h2>1. Introduction</h2>

<p>At present, the Networking TS's I/O objects -- sockets, acceptors, resolvers, and timers -- can be associated only with concrete execution contexts of type <code>io_context</code>. This paper proposes a minor change to the specification to permit the construction of these objects with arbitrary I/O executors and execution contexts. This would:</p>

<ul>
<li>allow implementers to support multiple "native" execution contexts, with different design and performance trade-offs; and</li>
<li>simplify some use cases, by allowing users to specify their preferred executor once, at construction, rather than on each operation.</li>
</ul>

<h2>2. Rationale</h2>

<h3>Construction with arbitrary execution contexts</h3>

<p>Users and third-party libraries may implement their own execution contexts, for example to provide different scheduling guarantees, or to natively support other types of I/O objects, such as files. This proposal would allow users to create the standard I/O objects, such as sockets, to be associated with these custom execution contexts. However, although constructing the socket with a custom execution context will provide the correct, expected behaviour, there is no guarantee that it will operate as efficiently as a socket associated with a native execution context.</p>

<h3>Support for multiple native execution contexts</h3>

<p>Some operating systems have multiple potential implementation strategies for the I/O objects, like sockets. For example, on Windows we can choose to have asynchronous notifications delivered via a completion port to a user-created thread, or we can have them delivered directly to the system thread pool. An implementer may want to make both of these strategies available, via the <code>io_context</code> and <code>system_context</code> execution contexts, respectively. For example:</p>

<pre>
  io_context my_context;
  tcp::socket my_socket_1(my_context); // Implementation uses a completion port.

  // ...

  tcp::socket my_socket_2(system_executor{}); // Implementation uses the system thread pool.
</pre>

<p>Libraries can also provide additional native execution contexts as implementation-specific extensions.</p>

<h3>Convenient construction with a preferred executor</h3>

<p>In some use cases, all asynchronous operations on a given I/O object are performed using the same executor. One common example of this is when using a strand. This proposal allows this executor to be specified once, when the I/O object is constructed. For example:</p>

<pre>
  io_context my_context;

  // ...

  strand&lt;io_context::executor_type&gt; my_strand(my_context.get_executor());
  tcp::socket my_socket(my_strand);

  // ...

  my_socket.async_receive(my_buffer, my_handler); // my_handler is invoked in the strand
</pre>

<h3>Vendor- or user-specialization of I/O object templates</h3>

<p>The <code>Executor</code> template parameter also offers an opportunity to specialize the I/O object types for specific executor types. For example, some platforms support vendor-specific kernel bypass APIs for I/O such as sockets, enabling significantly lower latency and higher throughput when compared to system calls. Furthermore, these APIs are often limited to supporting only TCP and UDP. A library or user may therefore choose to define an executor type that represents this API as a venue for I/O execution:</p>

<pre>
  class vendor_xyz_kernel_bypass_executor
  {
    // ...
  };
</pre>

<p>and specialize the socket templates for this executor type:</p>

<pre>
  template&lt;&gt;
  class basic_socket&lt;ip::tcp, vendor_xyz_kernel_bypass_executor&gt;
  {
    // ...
  };

  template&lt;&gt;
  class basic_datagram_socket&lt;ip::tcp, vendor_xyz_kernel_bypass_executor&gt;
    : public basic_socket&lt;ip::tcp, vendor_xyz_kernel_bypass_executor&gt;
  {
    // ...
    template&lt;class ConstBufferSequence&gt;
    void send(const ConstBufferSequence&amp; buffers)
    {
      // Implemented using vendor_xyz_send().
      // ...
    }
    // ...
  };
</pre>

<h2>3. Overview of changes to specification</h2>

<h3>Addition of Executor template parameter</h3>

<p>A new <code>Executor</code> template parameter is added to the following templates:</p>

<ul>
<li><code>basic_waitable_timer</code></li>
<li><code>basic_socket</code></li>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
<li><code>basic_socket_streambuf</code></li>
<li><code>basic_socket_iostream</code></li>
<li><code>ip::basic_resolver</code></li>
</ul>

<p>To enable convenient interoperability with arbitrary executors and execution contexts, the template parameter is defaulted to the <code>executor</code> polymorphic wrapper. For example:</p>

<pre>
  template &lt;class Protocol<ins>, class Executor = executor</ins>&gt;
    class basic_socket;
</pre>

<p>For each of:</p>

<ul>
<li><code>basic_waitable_timer</code></li>
<li><code>basic_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
<li><code>ip::basic_resolver</code></li>
</ul>

<p>the existing nested type <code>executor_type</code> is altered to refer to the <code>Executor</code> type:</p>

<pre>
  template &lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
  public:
    using executor_type = <del>io_context::executor_type</del><ins>Executor</ins>;
    // ...
  };
</pre>

<p>For the remaining four templates:</p>

<ul>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_streambuf</code></li>
<li><code>basic_socket_iostream</code></li>
</ul>

<p>the nested type <code>executor_type</code> is added:</p>

<pre>
  template &lt;class Protocol, class Executor&gt;
  class basic_stream_socket : public basic_socket&lt;Protocol, Executor&gt;
  {
  public:
    <ins>using executor_type = Executor</ins>;
    // ...
  };
</pre>

<h3>Addition of nested template type alias rebind_executor</h3>

<p>For each of the following templates:</p>

<ul>
<li><code>basic_waitable_timer</code></li>
<li><code>basic_socket</code></li>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
<li><code>ip::basic_resolver</code></li>
</ul>

<p>a nested template type alias <code>rebind_executor</code> is added:</p>

<pre>
  template&lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
    // ...

    /// The socket type when rebound to the specified executor.
    template&lt;class OtherExecutor&gt;
    using rebind_executor =
      basic_socket&lt;Protocol, OtherExecutor&gt;;

    // ...
  };
</pre>

<p>This enables computation of the appropriate class type for different I/O executor types.</p>

<h3>Modification of I/O objects' constructors</h3>

<p>For each of the following templates:</p>

<ul>
<li><code>basic_waitable_timer</code></li>
<li><code>basic_socket</code></li>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
<li><code>ip::basic_resolver</code></li>
</ul>

<p>every constructor with an <code>io_context&amp;</code> parameter is replaced with two constructors:</p>

<pre>
  template&lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
    // ...
    <del>basic_socket(io_context&amp; ctx, const protocol_type&amp; protocol);</del>
    <ins>basic_socket(const executor_type&amp; ex, const protocol_type&amp; protocol);</ins>
    <ins>template&lt;class ExecutionContext&gt;</ins>
      <ins>basic_socket(ExecutionContext&amp; ctx, const protocol_type&amp; protocol);</ins>
    // ...
  };
</pre>

<p>The second of these constructors shall not participate in overload resolution unless <code>is_convertible&lt;ExecutionContext&amp;, execution_context&amp;&gt;::value</code> is <code>true</code>, and <code>is_constructible&lt;executor_type, typename ExecutionContext::executor_type&gt;::value</code> is <code>true</code>.</p>

<h3>Modification of I/O objects' converting constructors</h3>

<p>An <code>OtherExecutor</code> template parameter is added as required to the converting move constructors of the following classes:</p>

<ul>
<li><code>basic_socket</code></li>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
</ul>

<p>For example:</p>

<pre>
  template&lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
    // ...
    template&lt;class OtherProtocol<ins>, class OtherExecutor</ins>&gt;
      basic_socket(basic_socket&lt;OtherProtocol<ins>, OtherExecutor</ins>&gt;&amp;&amp; rhs);
    // ...
  };
</pre>

<p>This constructor shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code>, and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<h3>Modification of I/O objects' converting assignment operators</h3>

<p>An <code>OtherExecutor</code> template parameter is added as required to the converting move assignment operators of the following classes:</p>

<ul>
<li><code>basic_socket</code></li>
<li><code>basic_datagram_socket</code></li>
<li><code>basic_stream_socket</code></li>
<li><code>basic_socket_acceptor</code></li>
</ul>

<p>For example:</p>

<pre>
  template&lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
    // ...
    template&lt;class OtherProtocol<ins>, class OtherExecutor</ins>&gt;
      basic_socket&amp; operator=(basic_socket&lt;OtherProtocol<ins>, OtherExecutor</ins>&gt;&amp;&amp; rhs);
    // ...
  };
</pre>

<p>This assignment operator shall not participate in overload resolution unless <code>OtherProtocol</code> is implicitly convertible to <code>Protocol</code>, and <code>OtherExecutor</code> is implicitly convertible to <code>Executor</code>.</p>

<div class="changed">

<h3>Addition of nested type alias socket_for to AcceptableProtocol requirements and protocol classes</h3>

<p>The <code>AcceptableProtocol</code> type requirements, <code>ip::tcp</code> class, and <code>ip::udp</code> class each acquire a new nested template type alias <code>socket_for</code>. It can be used to create a protocol socket with a specific executor type:</p>

<pre>
  net::ip::tcp::socket_for&lt;my_executor&gt; sock = /* ... */;
</pre>

<h3>Addition of template type alias to basic_socket_acceptor for using a socket with a specific executor</h3>

<p>The template <code>basic_socket_acceptor</code> gains a new nested template type alias <code>socket_type_for</code>:</p>

<pre>
  template&lt;class AcceptableProtocol, class Executor&gt;
  class basic_socket_acceptor : public socket_base
  {
    // ...

    template&lt;class OtherExecutor&gt;
    using socket_type_for = typename AcceptableProtocol::socket_for&lt;OtherExecutor&gt;;

    // ...
  };
</pre>

<p>This enables computation of the appropriate socket type produced when accepting on different I/O executor types.</p>

</div>

<h3>Modification of basic_socket_acceptor member functions</h3>

<p>Every overload of member functions <code>accept</code> and <code>async_accept</code> with an <code>io_context&amp;</code> parameter is replaced with two overloads:</p>

<pre class="changed">
  template&lt;class AcceptableProtocol, class Executor&gt;
  class basic_socket_acceptor : public socket_base
  {
    // ...
    <del>socket_type accept(io_context&amp; ctx);</del>
    <ins>template&lt;class OtherExecutor&gt;</ins>
      <ins>socket_type_for&lt;OtherExecutor&gt;</ins>
        <ins>accept(const OtherExecutor&amp; ex);</ins>
    <ins>template&lt;class ExecutionContext&gt;</ins>
      <ins>socket_type_for&lt;typename ExecutionContext::executor_type&gt;</ins>
        <ins>accept(ExecutionContext&amp; ctx);</ins>
    // ...
  };
</pre>

<p>The second of these overloads shall not participate in overload resolution unless <code>is_convertible&lt;ExecutionContext&amp;, execution_context&amp;&gt;::value</code> is <code>true</code>, and <code>is_constructible&lt;executor_type, typename ExecutionContext::executor_type&gt;::value</code> is <code>true</code>.</p>

<h3>Modification of connect and async_connect functions</h3>

<p>An <code>Executor</code> template parameter is added as required to the <code>connect</code> and <code>async_connect</code> functions. For example:</p>

<pre>
  template&lt;class Protocol<ins>, class Executor</ins>, class EndpointSequence&gt;
    typename Protocol::endpoint connect(basic_socket&lt;Protocol<ins>, Executor</ins>&gt;&amp; s,
                                        const EndpointSequence&amp; endpoints);
</pre>

<h3>Modification of basic_socket_streambuf</h3>

<p>The <code>basic_socket_streambuf</code> default constructor is modified so that it shall not participate in overload resolution unless <code>is_constructible&lt;executor_type, io_context::executor_type&gt;::value</code> is <code>true</code>.</p>

<h3>Modification of basic_socket_iostream</h3>

<p>The <code>basic_socket_iostream</code> specification is modified so that the <code>executor_type</code> type is passed to all uses of <code>basic_socket_streambuf</code>, as required. The <code>basic_socket_iostream</code> default constructor is modified so that it shall not participate in overload resolution unless <code>is_default_constructible&lt;basic_socket_streambuf&lt;protocol_type, clock_type, wait_traits_type, executor_type&gt;&gt;::value</code> is <code>true</code>.</p>

<h2>4. Possible implementation approach</h2>

<p>This section is intended to provide implementation suggestions only, and is not intended to be prescriptive or exhaustive.</p>

<h3>Provision of default implementation</h3>

<p>Implementations may use an execution context service as a container for the backend implementation.</p>

<pre>
  class __socket_backend : public execution_context::service
  {
    // ...
  };
</pre>

<p>This service would be "used" by an I/O object implementation, and is automatically created on first use:</p>

<pre>
  template &lt;class Protocol, class Executor&gt;
  class basic_socket : public socket_base
  {
  public:
    using executor_type = Executor;

    // ...

    explicit basic_socket(const executor_type&amp; ex)
    {
      auto&amp; backend = use_service&lt;__socket_backend&gt;(ex.context());
      // ...
    }

    // ...
  };
</pre>

<p>This allows the I/O object to be used with arbitrary execution contexts.</p>

<h3>Native implementations</h3>

<p>A native execution context preemptively performs service creation by calling <code>make_service</code>. It can use this opportunity to pass additional constructor arguments that initialise the backend in the native mode, rather than the default:</p>

<pre>
  class io_context : public execution_context
  {
  public:
    // ...

    io_context()
    {
      make_service&lt;__socket_backend&gt;(*this, __io_context_backend_tag{});
    }

    // ...
  };
</pre>

<p>Alternatively, implementations may use a class hierarchy of services, and virtual functions, to select the desired behaviour:</p>

<pre>
  class __socket_backend : public execution_context::service
  {
  public:
    using key_type =  __socket_backend;

    // ...

    virtual void backend_function(/* ... */);

    // ...
  };

  class __io_socket_backend : public __socket_backend
  {
  public:
    // ...

    void backend_function(/* ... */) override;

    // ...
  };

  class io_context : public execution_context
  {
  public:
    // ...

    io_context()
    {
      make_service&lt;__io_socket_backend&gt;(*this);
    }

    // ...
  };
</pre>

<p>In both approaches, the existing service, with its native backend, is obtained by the I/O object constructor.</p>

<h3>Performance impact</h3>

<p>Specification of the polymorphic executor as the default I/O executor, while improving usability, has a non-zero impact on performance. This impact can be mitigated by having an I/O object's constructor detect its own well-known native executor types (e.g. by using <code>executor::target_type</code>). With this information, the overhead can then be limited to simple branching, rather than the memory allocations and virtual functions that would likely be required for the type-erased function objects.</p>

<p>Users can avoid this overhead completely by explicitly specifying the I/O executor type:</p>

<pre>
  io_context my_context;
  basic_stream_socket&lt;tcp, io_context::executor_type&gt; my_socket(my_context);
</pre>

<h2>5. Implementation experience</h2>

<p>This design change was implemented in Asio 1.13.0, and was delivered in the Boost 1.70 release as the stable Asio version 1.14.0.</p>

<h2>6. Proposed changes to wording</h2>

<p>These changes are relative to N4771.</p>

<p><em>Update the <code>&lt;experimental/netfwd&gt;</code> synopsis [fwd.decl.synop] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>12.1</a> Header <span class='texttt'>&lt;experimental/netfwd&gt;</span> synopsis <a class='abbr_ref' href='#'>[fwd.decl.synop]</a></h2><pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>class</span> execution_context;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> T, <span class='keyword'>class</span> Executor<span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> executor_binder;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Executor<span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> executor_work_guard;
  <span class='keyword'>class</span> system_executor;
  <span class='keyword'>class</span> executor;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Executor<span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> strand;

  <span class='keyword'>class</span> io_context;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Clock<span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> wait_traits;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Clock, <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_waitable_timer;
  <span class='keyword'>using</span> system_timer <span class='operator'>=</span> basic_waitable_timer<span class='anglebracket'>&lt;</span>chrono<span class='operator'>::</span>system_clock<span class='anglebracket'>&gt;</span>;
  <span class='keyword'>using</span> steady_timer <span class='operator'>=</span> basic_waitable_timer<span class='anglebracket'>&lt;</span>chrono<span class='operator'>::</span>steady_clock<span class='anglebracket'>&gt;</span>;
  <span class='keyword'>using</span> high_resolution_timer <span class='operator'>=</span> basic_waitable_timer<span class='anglebracket'>&lt;</span>chrono<span class='operator'>::</span>high_resolution_clock<span class='anglebracket'>&gt;</span>;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_socket;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_datagram_socket;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_stream_socket;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_socket_acceptor;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock <span class='operator'>=</span> chrono<span class='operator'>::</span>steady_clock,
    <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_socket_streambuf;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock <span class='operator'>=</span> chrono<span class='operator'>::</span>steady_clock,
    <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_socket_iostream;

  <span class='keyword'>namespace</span> ip <span class='curlybracket'>{</span>

    <span class='keyword'>class</span> address;
    <span class='keyword'>class</span> address_v4;
    <span class='keyword'>class</span> address_v6;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Address<span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_address_iterator;
    <span class='keyword'>using</span> address_v4_iterator <span class='operator'>=</span> basic_address_iterator<span class='anglebracket'>&lt;</span>address_v4<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> address_v6_iterator <span class='operator'>=</span> basic_address_iterator<span class='anglebracket'>&lt;</span>address_v6<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Address<span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_address_range;
    <span class='keyword'>using</span> address_v4_range <span class='operator'>=</span> basic_address_range<span class='anglebracket'>&lt;</span>address_v4<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> address_v6_range <span class='operator'>=</span> basic_address_range<span class='anglebracket'>&lt;</span>address_v6<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>class</span> network_v4;
    <span class='keyword'>class</span> network_v6;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_endpoint;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_resolver_entry;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_resolver_results;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_resolver;
    <span class='keyword'>class</span> tcp;
    <span class='keyword'>class</span> udp;

  <span class='curlybracket'>}</span> <span class='comment'>// namespace ip</span>
<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre>
</div>

<p><em>Update the <code>&lt;experimental/timer&gt;</code> synopsis [timer.synop] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>15.1</a> Header <span class='texttt'>&lt;experimental/timer&gt;</span> synopsis <a class='abbr_ref' href='#'>[timer.synop]</a></h2>
</div>
<p><em>[...]</em></p>
<div class='wording'>
<pre class='codeblock'>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Clock, <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_waitable_timer;
</pre>
</div>

<p><em>Update the class template <code>basic_waitable_timer</code> [timer.waitable] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>15.4</a> Class template <span class='texttt'>basic_&shy;waitable_&shy;timer</span> <a class='abbr_ref' href='#'>[timer.waitable]</a></h2><span class='indexparent'><a class='index' id='lib:basic_waitable_timer'></a></span><pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Clock, <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_waitable_timer
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <span class='keyword'>using</span> executor_type <span class='operator'>=</span> <del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type</span></del><ins ><span class='tcode_in_codeblock'>Executor</span></ins>;
    <span class='keyword'>using</span> clock_type <span class='operator'>=</span> Clock;
    <span class='keyword'>using</span> duration <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>duration;
    <span class='keyword'>using</span> time_point <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>time_point;
    <span class='keyword'>using</span> traits_type <span class='operator'>=</span> WaitTraits;

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;waitable_&shy;timer<span class='anglebracket'>&lt;</span>Clock, WaitTraits, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#timer.waitable.cons'>[timer.waitable.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>explicit</span> basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> time_point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> time_&shy;point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;</span></ins>
    basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;</span></ins>
    basic_waitable_timer<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_waitable_timer<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_waitable_timer<span class='parenthesis'>(</span>basic_waitable_timer<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div>

<p><em>Update the <code>basic_waitable_timer</code> constructors [timer.waitable.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>15.4.1</a> <span class='texttt'>basic_&shy;waitable_&shy;timer</span> constructors <a class='abbr_ref' href='#'>[timer.waitable.cons]</a></h3><span class='indexparent'><a class='index' id='lib:basic_waitable_timer,constructor'></a></span><div class='itemdecl' id='timer.waitable.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='timer.waitable.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins>, time_&shy;point<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='timer.waitable.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='timer.waitable.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> time_point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='timer.waitable.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='timer.waitable.cons-2.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#timer.waitable.cons-2.1'>(2.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></del><ins >ex</ins></span>.</li><li id='timer.waitable.cons-2.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#timer.waitable.cons-2.2'>(2.2)</a></div><span class='texttt'>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> t</span>.</li></ul></div></div><div class='itemdecl' id='timer.waitable.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> time_&shy;point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, t<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='timer.waitable.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_waitable_timer<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='timer.waitable.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Sets the expiry time as if by calling <span class='texttt'>expires_&shy;after<span class='parenthesis'>(</span>d<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='timer.waitable.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></del><ins >ex</ins></span>.</div></div><div class='itemdecl' id='timer.waitable.cons-itemdecl:6'><div class='marginalizedparent'><a class='itemDeclLink' href='#timer.waitable.cons-itemdecl:6'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;waitable_&shy;timer<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, d<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div>
</div>

<p><em>Update the <code>&lt;experimental/socket&gt;</code> synopsis [socket.synop] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.1</a> Header <span class='texttt'>&lt;experimental/socket&gt;</span> synopsis <a class='abbr_ref' href='#'>[socket.synop]</a></h2><span class='indexparent'><a class='index' id='lib:socket_errc'></a></span><pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>enum</span> <span class='keyword'>class</span> socket_errc <span class='curlybracket'>{</span>
    already_open <span class='operator'>=</span> <span class='textit'>an <span class='indexparent'><a class='index' id=':value_of_socket_errc::already_open'></a></span>implementation-defined non-zero value</span>,
    not_found <span class='operator'>=</span> <span class='textit'>an <span class='indexparent'><a class='index' id=':value_of_socket_errc::not_found'></a></span>implementation-defined non-zero value</span>
  <span class='curlybracket'>}</span>;

  <span class='keyword'>const</span> error_category<span class='operator'>&amp;</span> socket_category<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

  error_code make_error_code<span class='parenthesis'>(</span>socket_errc e<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  error_condition make_error_condition<span class='parenthesis'>(</span>socket_errc e<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

  <span class='comment'>// Sockets:</span>

  <span class='keyword'>class</span> socket_base;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_socket;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_datagram_socket;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_stream_socket;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_socket_acceptor;

  <span class='comment'>// <a href='#socket.iostreams'>[socket.iostreams]</a>, Socket streams:</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock <span class='operator'>=</span> chrono<span class='operator'>::</span>steady_clock,
    <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_socket_streambuf;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock <span class='operator'>=</span> chrono<span class='operator'>::</span>steady_clock,
    <span class='keyword'>class</span> WaitTraits <span class='operator'>=</span> wait_traits<span class='anglebracket'>&lt;</span>Clock<span class='anglebracket'>&gt;</span><ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
      <span class='keyword'>class</span> basic_socket_iostream;

  <span class='comment'>// <a href='#socket.algo.connect'>[socket.algo.connect]</a>, synchronous connect operations:</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence<span class='anglebracket'>&gt;</span>
    <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                        <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence<span class='anglebracket'>&gt;</span>
    <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                        <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                        error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
    <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                        <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                        ConnectCondition c<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
    <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                        <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                        ConnectCondition c,
                                        error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator<span class='anglebracket'>&gt;</span>
    InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator<span class='anglebracket'>&gt;</span>
    InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
    InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
    InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

  <span class='comment'>// <a href='#socket.algo.async.connect'>[socket.algo.async.connect]</a>, asynchronous connect operations:</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> ConnectCondition,
           <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                          ConnectCondition c,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> ConnectCondition,
           <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;

<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='anglebracket'>&gt;</span> <span class='keyword'>struct</span> is_error_code_enum<span class='anglebracket'>&lt;</span>experimental<span class='operator'>::</span>net<span class='operator'>::</span>v1<span class='operator'>::</span>socket_errc<span class='anglebracket'>&gt;</span>
    <span class='operator'>:</span> <span class='keyword'>public</span> true_type <span class='curlybracket'>{</span><span class='curlybracket'>}</span>;

<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre>
</div>

<div class="changed">

<p><em>Update the <code>AcceptableProtocol</code> requirements [socket.reqmts.acceptableprotocol] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.2.7</a> Acceptable protocol requirements <a class='abbr_ref' href='#'>[socket.reqmts.acceptableprotocol]</a></h3><span class='indexparent'><a class='index' id=':Acceptable'></a></span><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.reqmts.acceptableprotocol.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>A type <span class='texttt'>X</span> meets the <span class='texttt'>AcceptableProtocol</span> requirements if it satisfies the requirements of <span class='texttt'>Protocol</span> (<a href='#socket.reqmts.protocol'>[socket.reqmts.protocol]</a>) as well as the additional requirements listed below.<div style='height:0.6em;display:block'></div><ins >In the table below, <span class='texttt'>E</span> is a type that satisfies the Executor requirements (<a href='#async.reqmts.executor'>[async.reqmts.executor]</a>).</ins><div class='numberedTable' id='tab:socket.reqmts.acceptableprotocol.requirements'>Table <a href='#tab:socket.reqmts.acceptableprotocol.requirements'>26</a>: AcceptableProtocol requirements<br><table ><tr class='rowsep'><td class='center'><b>expression</b></td><td class='center'><b>return type</b></td><td class='center'><b>assertion/note pre/post-conditions</b></td></tr><tr class='capsep'><td class='left'><div style='height:0.6em;display:block'></div><span class='texttt'>X<span class='operator'>&#x200b;::&#x200b;</span>socket</span></td><td class='left'>A type that satisfies the requirements of <span class='texttt'>Destructible</span> (C++2014[destructible]) and <span class='texttt'>MoveConstructible</span> (C++2014[moveconstructible]), and that is publicly and unambiguously derived from <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>X<span class='anglebracket'>&gt;</span></span>.</td><td class='empty left'></td></tr><tr ><td class='left'><ins ><span class='texttt'>X<span class='operator'>&#x200b;::&#x200b;</span>socket_&shy;for<span class='anglebracket'>&lt;</span>E<span class='anglebracket'>&gt;</span></span></ins></td><td class='left'><ins >A type that satisfies the requirements of <span class='texttt'>Destructible</span> (C++2014[destructible]) and <span class='texttt'>MoveConstructible</span> (C++2014[moveconstructible]), and that is publicly and unambiguously derived from <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>X, E<span class='anglebracket'>&gt;</span></span>.</ins></td><td class='empty left'></td></tr></table></div></div>
</div>

</div>

<p><em>Update the class <code>socket_base</code> [socket.base] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.4</a> Class <span class='texttt'>socket_&shy;base</span> <a class='abbr_ref' href='#'>[socket.base]</a></h2><pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>class</span> socket_base
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='keyword'>class</span> broadcast;
    <span class='keyword'>class</span> debug;
    <span class='keyword'>class</span> do_not_route;
    <span class='keyword'>class</span> keep_alive;
    <span class='keyword'>class</span> linger;
    <span class='keyword'>class</span> out_of_band_inline;
    <span class='keyword'>class</span> receive_buffer_size;
    <span class='keyword'>class</span> receive_low_watermark;
    <span class='keyword'>class</span> reuse_address;
    <span class='keyword'>class</span> send_buffer_size;
    <span class='keyword'>class</span> send_low_watermark;

    <span class='keyword'>using</span> shutdown_type <span class='operator'>=</span> <span class='textit'>T1</span>;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> shutdown_type shutdown_receive;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> shutdown_type shutdown_send;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> shutdown_type shutdown_both;

    <span class='keyword'>using</span> wait_type <span class='operator'>=</span> <span class='textit'>T2</span>;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> wait_type wait_read;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> wait_type wait_write;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> wait_type wait_error;

    <span class='keyword'>using</span> message_flags <span class='operator'>=</span> <span class='textit'>T3</span>;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> message_flags message_peek;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> message_flags message_out_of_band;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> message_flags message_do_not_route;

    <span class='keyword'>static</span> <span class='keyword'>const</span> <span class='keyword'>int</span> max_listen_connections;

  <span class='keyword'>protected</span><span class='operator'>:</span>
    socket_base<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='operator'>~</span>socket_base<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
  <span class='curlybracket'>}</span>;

<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.base.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='texttt'>socket_&shy;base</span> defines several member types:<ul class='itemize'><li id='socket.base-1.1'><div class='marginalizedparent' style='left:-7em'><a class='marginalized' href='#socket.base-1.1'>(1.1)</a></div>socket option classes <span class='texttt'>broadcast</span>, <span class='texttt'>debug</span>, <span class='texttt'>do_&shy;not_&shy;route</span>, <span class='texttt'>keep_&shy;alive</span>, <span class='texttt'>linger</span>, <span class='texttt'>out_&shy;of_&shy;band_&shy;inline</span>, <span class='texttt'>receive_&shy;buffer_&shy;size</span>, <span class='texttt'>receive_&shy;low_&shy;watermark</span>, <span class='texttt'>reuse_&shy;address</span>, <span class='texttt'>send_&shy;buffer_&shy;size</span>, and <span class='texttt'>send_&shy;low_&shy;watermark</span>;</li><li id='socket.base-1.2'><div class='marginalizedparent' style='left:-7em'><a class='marginalized' href='#socket.base-1.2'>(1.2)</a></div>an enumerated type, <span class='texttt'>shutdown_&shy;type</span>, for use with the <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> class's <span class='texttt'>shutdown</span> member function.</li><li id='socket.base-1.3'><div class='marginalizedparent' style='left:-7em'><a class='marginalized' href='#socket.base-1.3'>(1.3)</a></div>an enumerated type, <span class='texttt'>wait_&shy;type</span>, for use with the <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> and <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> classes' <span class='texttt'>wait</span> and <span class='texttt'>async_&shy;wait</span> member functions,</li><li id='socket.base-1.4'><div class='marginalizedparent' style='left:-7em'><a class='marginalized' href='#socket.base-1.4'>(1.4)</a></div>a bitmask type, <span class='texttt'>message_&shy;flags</span>, for use with the <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> class's <span class='texttt'>send</span>, <span class='texttt'>async_&shy;send</span>, <span class='texttt'>receive</span>, and <span class='texttt'>async_&shy;receive</span> member functions, and the <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<span class='anglebracket'>&gt;</span></span> class's <span class='texttt'>send</span>, <span class='texttt'>async_&shy;send</span>, <span class='texttt'>send_&shy;to</span>, <span class='texttt'>async_&shy;send_&shy;to</span>, <span class='texttt'>receive</span>, <span class='texttt'>async_&shy;receive</span>, <span class='texttt'>receive_&shy;from</span>, and <span class='texttt'>async_&shy;receive_&shy;from</span> member functions.</li><li id='socket.base-1.5'><div class='marginalizedparent' style='left:-7em'><a class='marginalized' href='#socket.base-1.5'>(1.5)</a></div>a constant, <span class='texttt'>max_&shy;listen_&shy;connections</span>, for use with the <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> class's <span class='texttt'>listen</span> member function.</li></ul></div>
</div>

<p><em>Update the class template <code>basic_socket</code> [socket.basic] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.6</a> Class template <span class='texttt'>basic_&shy;socket</span> <a class='abbr_ref' href='#'>[socket.basic]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>Class template <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> is used as the base class for the <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> and <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> class templates. It provides functionality that is common to both types of socket.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_socket <span class='operator'>:</span> <span class='keyword'>public</span> socket_base
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <span class='keyword'>using</span> executor_type <span class='operator'>=</span> <del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type</span></del><ins ><span class='tcode_in_codeblock'>Executor</span></ins>;
    <span class='keyword'>using</span> native_handle_type <span class='operator'>=</span> <span class='indexparent'><a class='index' id=':type_of_basic_socket::native_handle_type'></a></span><span class='textit'>implementation-defined</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> Protocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#socket.basic.ops'>[socket.basic.ops]</a>, basic_socket operations:</span>

    executor_type get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

    native_handle_type native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    <span class='keyword'>void</span> open<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol <span class='operator'>=</span> protocol_type<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> open<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> assign<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>void</span> assign<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket,
                error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    native_handle_type release<span class='parenthesis'>(</span><span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    native_handle_type release<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    <span class='keyword'>bool</span> is_open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span> <span class='keyword'>noexcept</span>;

    <span class='keyword'>void</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> close<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> cancel<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> cancel<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> SettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> set_option<span class='parenthesis'>(</span><span class='keyword'>const</span> SettableSocketOption<span class='operator'>&amp;</span> option<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> SettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> set_option<span class='parenthesis'>(</span><span class='keyword'>const</span> SettableSocketOption<span class='operator'>&amp;</span> option, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> GettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> get_option<span class='parenthesis'>(</span>GettableSocketOption<span class='operator'>&amp;</span> option<span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> GettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> get_option<span class='parenthesis'>(</span>GettableSocketOption<span class='operator'>&amp;</span> option, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> IoControlCommand<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> io_control<span class='parenthesis'>(</span>IoControlCommand<span class='operator'>&amp;</span> command<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> IoControlCommand<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> io_control<span class='parenthesis'>(</span>IoControlCommand<span class='operator'>&amp;</span> command, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <span class='keyword'>bool</span> non_blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> native_non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> native_non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <span class='keyword'>bool</span> native_non_blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>bool</span> at_mark<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    <span class='keyword'>bool</span> at_mark<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    size_t available<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    size_t available<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> bind<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> bind<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> shutdown<span class='parenthesis'>(</span>shutdown_type what<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> shutdown<span class='parenthesis'>(</span>shutdown_type what, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    endpoint_type local_endpoint<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    endpoint_type local_endpoint<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    endpoint_type remote_endpoint<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    endpoint_type remote_endpoint<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> connect<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> connect<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
      <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint,
                            CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> wait<span class='parenthesis'>(</span>wait_type w<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> wait<span class='parenthesis'>(</span>wait_type w, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
      <span class='textit'><span class='texttt'>DEDUCED</span></span> async_wait<span class='parenthesis'>(</span>wait_type w, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;

  <span class='keyword'>protected</span><span class='operator'>:</span>
    <span class='comment'>// <a href='#socket.basic.cons'>[socket.basic.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>explicit</span> basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
    basic_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
    basic_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                 <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
    <ins ><span class='tcode_in_codeblock'>               <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span></span></ins>
    basic_socket<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket<span class='parenthesis'>(</span>basic_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_socket<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='operator'>~</span>basic_socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

  <span class='keyword'>private</span><span class='operator'>:</span>
    protocol_type protocol_; <span class='comment'>// <span class='textit'>exposition only</span></span>
  <span class='curlybracket'>}</span>;

<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre></div>
</div>

<p><em>Update the <code>basic_socket</code> constructors [socket.basic.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.6.1</a> <span class='texttt'>basic_&shy;socket</span> constructors <a class='abbr_ref' href='#'>[socket.basic.cons]</a></h3><div class='itemdecl' id='socket.basic.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-1.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-1.1'>(1.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.basic.cons-1.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-1.2'>(1.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.basic.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.basic.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Opens this socket as if by calling <span class='texttt'>open<span class='parenthesis'>(</span>protocol<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-3.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-3.1'>(3.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.basic.cons-3.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-3.2'>(3.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.basic.cons-3.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-3.3'>(3.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.basic.cons-3.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-3.4'>(3.4)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> protocol</span>.</li></ul></div></div><div class='itemdecl' id='socket.basic.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.basic.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Opens and binds this socket as if by calling:
<pre class='codeblock'>
open<span class='parenthesis'>(</span>endpoint<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>;
bind<span class='parenthesis'>(</span>endpoint<span class='parenthesis'>)</span>;
</pre></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-5.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-5.1'>(5.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.basic.cons-5.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-5.2'>(5.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.basic.cons-5.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-5.3'>(5.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.basic.cons-5.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-5.4'>(5.4)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> endpoint<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.basic.cons-itemdecl:6'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:6'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, endpoint<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.basic.cons-itemdecl:7'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:7'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
             <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>native_&shy;socket</span> is a native handle to an open socket.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Assigns the existing native socket into this socket as if by calling <span class='texttt'>assign<span class='parenthesis'>(</span>protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-8.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-8.1'>(8.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.basic.cons-8.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-8.2'>(8.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.basic.cons-8.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-8.3'>(8.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.basic.cons-8.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-8.4'>(8.4)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> protocol</span>.</li></ul></div></div><div class='itemdecl' id='socket.basic.cons-itemdecl:8'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:8'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
<ins ><span class='texttt'>               <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.basic.cons-itemdecl:9'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:9'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='parenthesis'>(</span>basic_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#9'>9</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> that refers to the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#10'>10</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-10.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.1'>(10.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.cons-10.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.2'>(10.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.basic.cons-10.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.3'>(10.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.basic.cons-10.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.4'>(10.4)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the prior value of <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.cons-10.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.5'>(10.5)</a></div><span class='texttt'>protocol_&shy;</span> is the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.basic.cons-10.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-10.6'>(10.6)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.basic.cons-itemdecl:10'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.cons-itemdecl:10'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_socket<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#11'>11</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#12'>12</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> that refers to the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#13'>13</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.cons-13.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.1'>(13.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.cons-13.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.2'>(13.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.basic.cons-13.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.3'>(13.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.basic.cons-13.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.4'>(13.4)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the prior value of <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.cons-13.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.5'>(13.5)</a></div><span class='texttt'>protocol_&shy;</span> is the result of converting the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.basic.cons-13.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.cons-13.6'>(13.6)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.cons.html#14'>14</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This constructor shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the <code>basic_socket</code> assignment operators [socket.basic.assign] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.6.3</a> <span class='texttt'>basic_&shy;socket</span> assignment <a class='abbr_ref' href='#'>[socket.basic.assign]</a></h3><div class='itemdecl' id='socket.basic.assign-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.assign-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If <span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> is <span class='texttt'><span class='literal'>true</span></span>, cancels all outstanding asynchronous operations associated with this socket. Completion handlers for canceled operations are passed an error code <span class='texttt'>ec</span> such that <span class='texttt'>ec <span class='operator'>=</span><span class='operator'>=</span> errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> yields <span class='texttt'><span class='literal'>true</span></span>. Disables the linger socket option to prevent the assignment from blocking, and releases socket resources as if by POSIX <span class='texttt'>close<span class='parenthesis'>(</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. Moves into <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.assign-2.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-2.1'>(2.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.assign-2.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-2.2'>(2.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.basic.assign-2.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-2.3'>(2.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.basic.assign-2.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-2.4'>(2.4)</a></div><span class='texttt'>protocol_&shy;</span> is the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.basic.assign-2.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-2.5'>(2.5)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='itemdecl' id='socket.basic.assign-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.basic.assign-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If <span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> is <span class='texttt'><span class='literal'>true</span></span>, cancels all outstanding asynchronous operations associated with this socket. Completion handlers for canceled operations are passed an error code <span class='texttt'>ec</span> such that <span class='texttt'>ec <span class='operator'>=</span><span class='operator'>=</span> errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> yields <span class='texttt'><span class='literal'>true</span></span>. Disables the linger socket option to prevent the assignment from blocking, and releases socket resources as if by POSIX <span class='texttt'>close<span class='parenthesis'>(</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. Moves into <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.basic.assign-6.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-6.1'>(6.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.basic.assign-6.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-6.2'>(6.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.basic.assign-6.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-6.3'>(6.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.basic.assign-6.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-6.4'>(6.4)</a></div><span class='texttt'>protocol_&shy;</span> is the result of converting the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.basic.assign-6.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.basic.assign-6.5'>(6.5)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.basic.assign.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This assignment operator shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the class template <code>basic_datagram_socket</code> [socket.basic] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.7</a> Class template <span class='texttt'>basic_&shy;datagram_&shy;socket</span> <a class='abbr_ref' href='#'>[socket.dgram]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class template <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> is used to send and receive discrete messages of fixed maximum length.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_datagram_socket <span class='operator'>:</span> <span class='keyword'>public</span> basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> executor_&shy;type <span class='operator'>=</span> Executor;</span></ins>
    <span class='keyword'>using</span> native_handle_type <span class='operator'>=</span> <span class='indexparent'><a class='index' id=':type_of_basic_datagram_socket::native_handle_type'></a></span><span class='textit'>implementation-defined</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> Protocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#socket.dgram.cons'>[socket.dgram.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>explicit</span> basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
    basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
    basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                          <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
    <ins ><span class='tcode_in_codeblock'>                        <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
    basic_datagram_socket<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_datagram_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_datagram_socket<span class='parenthesis'>(</span>basic_datagram_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_datagram_socket<span class='parenthesis'>(</span>basic_datagram_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='operator'>~</span>basic_datagram_socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_datagram_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_datagram_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_datagram_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_datagram_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_datagram_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_datagram_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div>
</div>
<p><em>[...]</em></p>
<div class='wording'>
<div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.html#6'>6</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>If <span class='texttt'>native_&shy;handle_&shy;type</span> and <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>native_&shy;handle_&shy;type</span>
are both defined then they name the same type.</div>
</div>

<p><em>Update the <code>basic_datagram_socket</code> constructors [socket.dgram.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.7.1</a> <span class='texttt'>basic_&shy;datagram_&shy;socket</span> constructors <a class='abbr_ref' href='#'>[socket.dgram.cons]</a></h3><div class='itemdecl' id='socket.dgram.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, protocol<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_datagram_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, endpoint<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:6'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:6'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, endpoint<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:7'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:7'>🔗</a></div><pre class='itemdeclcode'>basic_datagram_socket<span class='parenthesis'>(</span>io_context<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                      <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:8'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:8'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
<ins ><span class='texttt'>                        <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:9'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:9'>🔗</a></div><pre class='itemdeclcode'>basic_datagram_socket<span class='parenthesis'>(</span>basic_datagram_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span>, initializing the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.dgram.cons-itemdecl:10'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.cons-itemdecl:10'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_datagram_socket<span class='parenthesis'>(</span>basic_datagram_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span>, initializing the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.cons.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This constructor shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the <code>basic_datagram_socket</code> assignment operators [socket.dgram.assign] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.7.2</a> <span class='texttt'>basic_&shy;datagram_&shy;socket</span> assignment <a class='abbr_ref' href='#'>[socket.dgram.assign]</a></h3><div class='itemdecl' id='socket.dgram.assign-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.assign-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_datagram_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_datagram_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span><span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='itemdecl' id='socket.dgram.assign-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.dgram.assign-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_datagram_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_datagram_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span><span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.dgram.assign.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This assignment operator not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the class template <code>basic_stream_socket</code> [socket.stream] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.8</a> Class template <span class='texttt'>basic_&shy;stream_&shy;socket</span> <a class='abbr_ref' href='#'>[socket.stream]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class template <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> is used to exchange data with a peer over a sequenced, reliable, bidirectional, connection-mode byte stream.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_stream_socket <span class='operator'>:</span> <span class='keyword'>public</span> basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='tcode_in_codeblock'>, Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> executor_&shy;type <span class='operator'>=</span> Executor;</span></ins>
    <span class='keyword'>using</span> native_handle_type <span class='operator'>=</span> <span class='indexparent'><a class='index' id=':type_of_basic_stream_socket::native_handle_type'></a></span><span class='textit'>implementation-defined</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> Protocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#socket.stream.cons'>[socket.stream.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_stream_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>explicit</span> basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_stream_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
    basic_stream_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
    basic_stream_socket<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                 <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
    <ins ><span class='tcode_in_codeblock'>               <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
    basic_stream_socket<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_stream_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_stream_socket<span class='parenthesis'>(</span>basic_stream_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_stream_socket<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='operator'>~</span>basic_stream_socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_stream_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_stream_socket<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_stream_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_stream_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_stream_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div>
</div>
<p><em>[...]</em></p>
<div class='wording'>
<div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.html#6'>6</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>If <span class='texttt'>native_&shy;handle_&shy;type</span> and <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>native_&shy;handle_&shy;type</span>
are both defined then they name the same type.</div>
</div>

<p><em>Update the <code>basic_stream_socket</code> constructors [socket.stream.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.8.1</a> <span class='texttt'>basic_&shy;stream_&shy;socket</span> constructors <a class='abbr_ref' href='#'>[socket.stream.cons]</a></h3><div class='itemdecl' id='socket.stream.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_stream_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.stream.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.stream.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_stream_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, protocol<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.stream.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.stream.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_stream_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, endpoint<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.stream.cons-itemdecl:6'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:6'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, endpoint<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.stream.cons-itemdecl:7'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:7'>🔗</a></div><pre class='itemdeclcode'>basic_stream_socket<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                    <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>ctx, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.stream.cons-itemdecl:8'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:8'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
<ins ><span class='texttt'>                      <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;stream_&shy;socket<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.stream.cons-itemdecl:9'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:9'>🔗</a></div><pre class='itemdeclcode'>basic_stream_socket<span class='parenthesis'>(</span>basic_stream_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span>, initializing the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.stream.cons-itemdecl:10'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.cons-itemdecl:10'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_stream_socket<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span>, initializing the base class with <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.cons.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This constructor shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the <code>basic_stream_socket</code> assignment operators [socket.stream.assign] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.8.2</a> <span class='texttt'>basic_&shy;stream_&shy;socket</span> assignment <a class='abbr_ref' href='#'>[socket.stream.assign]</a></h3><div class='itemdecl' id='socket.stream.assign-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.assign-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_stream_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_stream_socket<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span><span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='itemdecl' id='socket.stream.assign-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.stream.assign-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_stream_socket<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>Protocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span><span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>rhs<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.stream.assign.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This assignment operator shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the class template <code>basic_socket_acceptor</code> [socket.acceptor] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>18.9</a> Class template <span class='texttt'>basic_&shy;socket_&shy;acceptor</span> <a class='abbr_ref' href='#'>[socket.acceptor]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>An object of class template <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>AcceptableProtocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> is used to listen for, and queue, incoming socket connections. Socket objects that represent the incoming connections are dequeued by calling <span class='texttt'>accept</span> or <span class='texttt'>async_&shy;accept</span>.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> AcceptableProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_socket_acceptor <span class='operator'>:</span> <span class='keyword'>public</span> socket_base
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <span class='keyword'>using</span> executor_type <span class='operator'>=</span> <del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type</span></del><ins ><span class='tcode_in_codeblock'>Executor</span></ins>;
    <span class='keyword'>using</span> native_handle_type <span class='operator'>=</span> <span class='indexparent'><a class='index' id=':type_of_basic_socket_acceptor::native_handle_type'></a></span><span class='textit'>implementation-defined</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> AcceptableProtocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;
    <span class='keyword'>using</span> socket_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>socket;
<div class="changed">    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> socket_&shy;type_&shy;for</span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_&shy;type<span class='operator'>&#x200b;::&#x200b;</span>socket_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins></div>

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>AcceptableProtocol, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#socket.acceptor.cons'>[socket.acceptor.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>explicit</span> basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
    basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint,
                          <span class='keyword'>bool</span> reuse_addr <span class='operator'>=</span> <span class='literal'>true</span><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
    <ins ><span class='tcode_in_codeblock'>                        <span class='keyword'>bool</span> reuse_&shy;addr <span class='operator'>=</span> <span class='literal'>true</span><span class='parenthesis'>)</span>;</span></ins>
    basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                          <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_socket<span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
    <ins ><span class='tcode_in_codeblock'>                        <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
    basic_socket_acceptor<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_acceptor<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_acceptor<span class='parenthesis'>(</span>basic_socket_acceptor<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_socket_acceptor<span class='parenthesis'>(</span>basic_socket_acceptor<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='operator'>~</span>basic_socket_acceptor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_socket_acceptor<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_acceptor<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_acceptor<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_acceptor<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
      basic_socket_acceptor<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_acceptor<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='tcode_in_codeblock'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='comment'>// <a href='#socket.acceptor.ops'>[socket.acceptor.ops]</a>, basic_socket_acceptor operations:</span>

    executor_type get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

    native_handle_type native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    <span class='keyword'>void</span> open<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol <span class='operator'>=</span> protocol_type<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> open<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> assign<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_acceptor<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    <span class='keyword'>void</span> assign<span class='parenthesis'>(</span><span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_acceptor,
                error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    native_handle_type release<span class='parenthesis'>(</span><span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>
    native_handle_type release<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>; <span class='comment'>// see <a href='#socket.reqmts.native'>[socket.reqmts.native]</a></span>

    <span class='keyword'>bool</span> is_open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span> <span class='keyword'>noexcept</span>;

    <span class='keyword'>void</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> close<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> cancel<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> cancel<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> SettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> set_option<span class='parenthesis'>(</span><span class='keyword'>const</span> SettableSocketOption<span class='operator'>&amp;</span> option<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> SettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> set_option<span class='parenthesis'>(</span><span class='keyword'>const</span> SettableSocketOption<span class='operator'>&amp;</span> option, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> GettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> get_option<span class='parenthesis'>(</span>GettableSocketOption<span class='operator'>&amp;</span> option<span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> GettableSocketOption<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> get_option<span class='parenthesis'>(</span>GettableSocketOption<span class='operator'>&amp;</span> option, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> IoControlCommand<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> io_control<span class='parenthesis'>(</span>IoControlCommand<span class='operator'>&amp;</span> command<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> IoControlCommand<span class='anglebracket'>&gt;</span>
      <span class='keyword'>void</span> io_control<span class='parenthesis'>(</span>IoControlCommand<span class='operator'>&amp;</span> command, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <span class='keyword'>bool</span> non_blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> native_non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> native_non_blocking<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <span class='keyword'>bool</span> native_non_blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> bind<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> bind<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> listen<span class='parenthesis'>(</span><span class='keyword'>int</span> backlog <span class='operator'>=</span> max_listen_connections<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> listen<span class='parenthesis'>(</span><span class='keyword'>int</span> backlog, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;

    endpoint_type local_endpoint<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    endpoint_type local_endpoint<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    <span class='keyword'>void</span> enable_connection_aborted<span class='parenthesis'>(</span><span class='keyword'>bool</span> mode<span class='parenthesis'>)</span>;
    <span class='keyword'>bool</span> enable_connection_aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    socket_type accept<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    socket_type accept<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <del ><span class='tcode_in_codeblock'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></del>
    <del ><span class='tcode_in_codeblock'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></del>
<div class="changed">    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins></div>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
      <span class='textit'><span class='texttt'>DEDUCED</span></span> async_accept<span class='parenthesis'>(</span>CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
    <del ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></del>
    <del ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></del>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>

    socket_type accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
    socket_type accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
    <del ><span class='tcode_in_codeblock'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></del>
    <del ><span class='tcode_in_codeblock'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></del>
    <del ><span class='tcode_in_codeblock'>                   error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></del>
<div class="changed">    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins></div>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
      <span class='textit'><span class='texttt'>DEDUCED</span></span> async_accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint,
                           CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
    <del ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></del>
    <del ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></del>
    <del ><span class='tcode_in_codeblock'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></del>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
    <ins ><span class='tcode_in_codeblock'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
    <ins ><span class='tcode_in_codeblock'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
</pre></div>
</div>

<p><em>Update the <code>basic_socket_acceptor</code> constructors [socket.stream.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.9.1</a> <span class='texttt'>basic_&shy;socket_&shy;acceptor</span> constructors <a class='abbr_ref' href='#'>[socket.acceptor.cons]</a></h3><div class='itemdecl' id='socket.acceptor.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-1.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-1.1'>(1.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.acceptor.cons-1.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-1.2'>(1.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Opens this acceptor as if by calling <span class='texttt'>open<span class='parenthesis'>(</span>protocol<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-3.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-3.1'>(3.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.acceptor.cons-3.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-3.2'>(3.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.acceptor.cons-3.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-3.3'>(3.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-3.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-3.4'>(3.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-3.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-3.5'>(3.5)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> protocol</span>.</li></ul></div></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> endpoint,
                      <span class='keyword'>bool</span> reuse_addr <span class='operator'>=</span> <span class='literal'>true</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Opens and binds this acceptor as if by calling:
<pre class='codeblock'>
open<span class='parenthesis'>(</span>endpoint<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>;
<span class='keyword'>if</span> <span class='parenthesis'>(</span>reuse_addr<span class='parenthesis'>)</span>
  set_option<span class='parenthesis'>(</span>reuse_address<span class='parenthesis'>(</span><span class='literal'>true</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>;
bind<span class='parenthesis'>(</span>endpoint<span class='parenthesis'>)</span>;
listen<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-5.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-5.1'>(5.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.acceptor.cons-5.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-5.2'>(5.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.acceptor.cons-5.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-5.3'>(5.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-5.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-5.4'>(5.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-5.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-5.5'>(5.5)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> endpoint<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:6'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:6'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='keyword'>explicit</span> basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
<ins ><span class='texttt'>                                 <span class='keyword'>bool</span> reuse_&shy;addr <span class='operator'>=</span> <span class='literal'>true</span><span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, endpoint, reuse_&shy;addr<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:7'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:7'>🔗</a></div><pre class='itemdeclcode'>basic_socket_acceptor<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins>, <span class='keyword'>const</span> protocol_type<span class='operator'>&amp;</span> protocol,
                      <span class='keyword'>const</span> native_handle_type<span class='operator'>&amp;</span> native_acceptor<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>native_&shy;acceptor</span> is a native handle to an open acceptor.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Assigns the existing native acceptor into this acceptor as if by calling <span class='texttt'>assign<span class='parenthesis'>(</span>protocol, native_&shy;acceptor<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-8.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-8.1'>(8.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_&shy;executor()</del><ins >ex</ins></span>.</li><li id='socket.acceptor.cons-8.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-8.2'>(8.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>true</span></span>.</li><li id='socket.acceptor.cons-8.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-8.3'>(8.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-8.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-8.4'>(8.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li><li id='socket.acceptor.cons-8.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-8.5'>(8.5)</a></div><span class='texttt'>protocol_&shy; <span class='operator'>=</span><span class='operator'>=</span> protocol</span>.</li></ul></div></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:8'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:8'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, <span class='keyword'>const</span> protocol_&shy;type<span class='operator'>&amp;</span> protocol,</span></ins>
<ins ><span class='texttt'>                        <span class='keyword'>const</span> native_&shy;handle_&shy;type<span class='operator'>&amp;</span> native_&shy;socket<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Effects:</span>Equivalent to <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, protocol, native_&shy;socket<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:9'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:9'>🔗</a></div><pre class='itemdeclcode'>basic_socket_acceptor<span class='parenthesis'>(</span>basic_socket_acceptor<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#9'>9</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>AcceptableProtocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> that refers to the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#10'>10</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-10.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.1'>(10.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.acceptor.cons-10.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.2'>(10.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-10.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.3'>(10.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-10.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.4'>(10.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-10.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.5'>(10.5)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-10.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.6'>(10.6)</a></div><span class='texttt'>protocol_&shy;</span> is equal to the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.acceptor.cons-10.7'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-10.7'>(10.7)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='itemdecl' id='socket.acceptor.cons-itemdecl:10'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.cons-itemdecl:10'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_socket_acceptor<span class='parenthesis'>(</span>basic_socket_acceptor<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#11'>11</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#12'>12</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;socket_&shy;acceptor<span class='anglebracket'>&lt;</span>AcceptableProtocol<ins >, Executor</ins><span class='anglebracket'>&gt;</span></span> that refers to the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#13'>13</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.cons-13.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.1'>(13.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.acceptor.cons-13.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.2'>(13.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-13.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.3'>(13.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-13.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.4'>(13.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the constructor invocation.</li><li id='socket.acceptor.cons-13.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.5'>(13.5)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the prior value of <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.acceptor.cons-13.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.6'>(13.6)</a></div><span class='texttt'>protocol_&shy;</span> is the result of converting the prior value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span>.</li><li id='socket.acceptor.cons-13.7'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.cons-13.7'>(13.7)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.cons.html#14'>14</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This constructor shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the <code>basic_socket_acceptor</code> assignment operators [socket.stream.assign] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.9.3</a> <span class='texttt'>basic_&shy;socket_&shy;acceptor</span> assignment <a class='abbr_ref' href='#'>[socket.acceptor.assign]</a></h3>


<div class='itemdecl' id='socket.acceptor.assign-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.assign-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_socket_acceptor<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_acceptor<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If <span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> is <span class='texttt'><span class='literal'>true</span></span>, cancels all outstanding asynchronous operations associated with this acceptor, and releases acceptor resources as if by POSIX <span class='texttt'>close<span class='parenthesis'>(</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. Then moves into <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> the state originally represented by <span class='texttt'>rhs</span>. Completion handlers for canceled operations are passed an error code <span class='texttt'>ec</span> such that <span class='texttt'>ec <span class='operator'>=</span><span class='operator'>=</span> errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> yields <span class='texttt'><span class='literal'>true</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.assign-2.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.1'>(2.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.acceptor.assign-2.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.2'>(2.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-2.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.3'>(2.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-2.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.4'>(2.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-2.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.5'>(2.5)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-2.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.6'>(2.6)</a></div><span class='texttt'>protocol_&shy;</span> is the same value as <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span> prior to the assignment.</li><li id='socket.acceptor.assign-2.7'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-2.7'>(2.7)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='itemdecl' id='socket.acceptor.assign-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.assign-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherProtocol<ins ><span class='texttt'>, <span class='keyword'>class</span> OtherExecutor</span></ins><span class='anglebracket'>&gt;</span>
  basic_socket_acceptor<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_acceptor<span class='anglebracket'>&lt;</span>OtherProtocol<ins ><span class='texttt'>, OtherExecutor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Requires:</span><span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If <span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> is <span class='texttt'><span class='literal'>true</span></span>, cancels all outstanding asynchronous operations associated with this acceptor, and releases acceptor resources as if by POSIX <span class='texttt'>close<span class='parenthesis'>(</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. Then moves into <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> the state originally represented by <span class='texttt'>rhs</span>. Completion handlers for canceled operations are passed an error code <span class='texttt'>ec</span> such that <span class='texttt'>ec <span class='operator'>=</span><span class='operator'>=</span> errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> yields <span class='texttt'><span class='literal'>true</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>
<ul class='itemize'><li id='socket.acceptor.assign-6.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.1'>(6.1)</a></div><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</li><li id='socket.acceptor.assign-6.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.2'>(6.2)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-6.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.3'>(6.3)</a></div><span class='texttt'>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>non_&shy;blocking<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-6.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.4'>(6.4)</a></div><span class='texttt'>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>enable_&shy;connection_&shy;aborted<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-6.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.5'>(6.5)</a></div><span class='texttt'>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> returns the same value as <span class='texttt'>rhs<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> prior to the assignment.</li><li id='socket.acceptor.assign-6.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.6'>(6.6)</a></div><span class='texttt'>protocol_&shy;</span> is the result of converting the value of <span class='texttt'>rhs<span class='operator'>.</span>protocol_&shy;</span> prior to the assignment.</li><li id='socket.acceptor.assign-6.7'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.acceptor.assign-6.7'>(6.7)</a></div><span class='texttt'>rhs<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.assign.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This assignment operator shall not participate in overload resolution unless <span class='texttt'>OtherProtocol</span> is implicitly convertible to <span class='texttt'>Protocol</span><ins > and <span class='texttt'>OtherExecutor</span> is implicitly convertible to <span class='texttt'>Executor</span></ins>.</div></div>
</div>

<p><em>Update the <code>basic_socket_acceptor</code> operations [socket.stream.ops] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>18.9.4</a> <span class='texttt'>basic_&shy;socket_&shy;acceptor</span> operations <a class='abbr_ref' href='#'>[socket.acceptor.ops]</a></h3>
</div>
<p><em>[...]</em></p>  
<div class='wording'>
<div class='itemdecl' id='socket.acceptor.ops-itemdecl:21'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:21'>🔗</a></div><pre class='itemdeclcode'>socket_type accept<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
socket_type accept<span class='parenthesis'>(</span>error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.ops.html#40'>40</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>accept<span class='parenthesis'>(</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><del >.context()</del>, ec<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:22'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:22'>🔗</a></div><pre class='itemdeclcode'><del ><span class='texttt'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></del>
<del ><span class='texttt'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></del>
<ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex<span class='parenthesis'>)</span>;</span></ins>
<ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.ops.html#41'>41</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Extracts a socket from the queue of pending connections of the acceptor, as if by POSIX:
<pre class='codeblock'>
native_handle_type h <span class='operator'>=</span> accept<span class='parenthesis'>(</span>native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, <span class='literal'>nullptr</span>, <span class='literal'>0</span><span class='parenthesis'>)</span>;
</pre></div></div><div class='para' id='42'><div class='marginalizedparent'><a class='marginalized' href='#42'>42</a></div><div class='itemdescr changed'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>On success, <span class='texttt'>socket_&shy;type<ins >_&shy;for&lt;OtherExecutor&gt;</ins><span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins>, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise <span class='texttt'>socket_&shy;type<ins >_&shy;for&lt;OtherExecutor&gt;</ins><span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='itemdecl:23'><div class='marginalizedparent'><a class='itemDeclLink' href='#itemdecl:23'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
<ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Returns:</span><span class='texttt'>accept<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:24'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:24'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
  <span class='textit'><span class='texttt'>DEDUCED</span></span> async_accept<span class='parenthesis'>(</span>CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#43'>43</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>
<pre class='codeblock'>
async_accept<span class='parenthesis'>(</span>get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><del ><span class='tcode_in_codeblock'><span class='operator'>.</span>context<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></del>, forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span>
</pre></div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:25'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:25'>🔗</a></div><pre class='itemdeclcode'><del ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></del>
<del ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></del>
<ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr changed'><ins >Let <span class='texttt'>S</span> be the type <span class='texttt'>socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span>.</ins></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#44'>44</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Completion signature:</span><span class='texttt'><span class='keyword'>void</span><span class='parenthesis'>(</span>error_&shy;code ec, <del >socket_&shy;type</del><ins >S</ins> s<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#45'>45</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initiates an asynchronous operation to extract a socket from the queue of pending connections of the acceptor, as if by POSIX:
<pre class='codeblock'>
native_handle_type h <span class='operator'>=</span> accept<span class='parenthesis'>(</span>native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, <span class='literal'>nullptr</span>, <span class='literal'>0</span><span class='parenthesis'>)</span>;
</pre>
<del >On success, <span class='texttt'>s</span> is <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span>ctx, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise,  <span class='texttt'>s</span> is  <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span>ctx<span class='parenthesis'>)</span></span>.</del>
<ins >On success, <span class='texttt'>s</span> is <span class='texttt'>S<span class='parenthesis'>(</span>ex, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise,  <span class='texttt'>s</span> is  <span class='texttt'>S<span class='parenthesis'>(</span>ex<span class='parenthesis'>)</span></span>.</ins></div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:26'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:26'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Returns:</span></ins>
<pre class='codeblock'>
<ins ><span class='tcode_in_codeblock'>async_&shy;accept<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span></ins>
</pre></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:27'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:27'>🔗</a></div><pre class='itemdeclcode'>socket_type accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;
socket_type accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#46'>46</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>accept<span class='parenthesis'>(</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><del >.context()</del>, endpoint, ec<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:28'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:28'>🔗</a></div><pre class='itemdeclcode'><del ><span class='texttt'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></del>
<del ><span class='texttt'>socket_&shy;type accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></del>
<del ><span class='texttt'>                   error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></del>
<ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
<ins ><span class='texttt changed'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt changed'>    accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#47'>47</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Extracts a socket from the queue of pending connections of the acceptor, as if by POSIX:
<pre class='codeblock'>
socklen_t endpoint_len <span class='operator'>=</span> endpoint<span class='operator'>.</span>capacity<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
native_handle_type h <span class='operator'>=</span> accept<span class='parenthesis'>(</span>native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>,
                              endpoint<span class='operator'>.</span>data<span class='parenthesis'>(</span><span class='parenthesis'>)</span>,
                              <span class='operator'>&amp;</span>endpoint_len<span class='parenthesis'>)</span>;
<span class='keyword'>if</span> <span class='parenthesis'>(</span>h <span class='anglebracket'>&gt;</span><span class='operator'>=</span> <span class='literal'>0</span><span class='parenthesis'>)</span>
  endpoint<span class='operator'>.</span>resize<span class='parenthesis'>(</span>endpoint_len<span class='parenthesis'>)</span>;
</pre></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#48'>48</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>On success, <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins>, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span><del >ctx</del><ins >ex</ins><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl changed' id='socket.acceptor.ops-itemdecl:29'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:29'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint<span class='parenthesis'>)</span>;</span></ins>
<ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span><span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>    accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint, error_&shy;code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Returns:</span><span class='texttt'>accept<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, endpoint, ec<span class='parenthesis'>)</span></span>.</ins></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:30'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:30'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
  <span class='textit'><span class='texttt'>DEDUCED</span></span> async_accept<span class='parenthesis'>(</span>endpoint_type<span class='operator'>&amp;</span> endpoint,
                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.acceptor.ops.html#49'>49</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>
<pre class='codeblock'>
async_accept<span class='parenthesis'>(</span>get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span><del ><span class='tcode_in_codeblock'><span class='operator'>.</span>context<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></del>, endpoint, forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span>
</pre></div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:31'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:31'>🔗</a></div><pre class='itemdeclcode'><del ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></del>
<del ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>io_&shy;context<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></del>
<del ><span class='texttt'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></del>
<ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span><span class='keyword'>const</span> OtherExecutor<span class='operator'>&amp;</span> ex, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
<ins ><span class='texttt'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr changed'><ins >Let <span class='texttt'>S</span> be the type <span class='texttt'>socket_&shy;type_&shy;for<span class='anglebracket'>&lt;</span>OtherExecutor<span class='anglebracket'>&gt;</span></span>.</ins></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#50'>50</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Completion signature:</span><span class='texttt'><span class='keyword'>void</span><span class='parenthesis'>(</span>error_&shy;code ec, <del >socket_&shy;type</del><ins >S</ins> s<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='#51'>51</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initiates an asynchronous operation to extract a socket from the queue of pending connections of the acceptor, as if by POSIX:
<pre class='codeblock'>
socklen_t endpoint_len <span class='operator'>=</span> endpoint<span class='operator'>.</span>capacity<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
native_handle_type h <span class='operator'>=</span> accept<span class='parenthesis'>(</span>native_handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>,
                              endpoint<span class='operator'>.</span>data<span class='parenthesis'>(</span><span class='parenthesis'>)</span>,
                              <span class='operator'>&amp;</span>endpoint_len<span class='parenthesis'>)</span>;
<span class='keyword'>if</span> <span class='parenthesis'>(</span>h <span class='anglebracket'>&gt;</span><span class='operator'>=</span> <span class='literal'>0</span><span class='parenthesis'>)</span>
  endpoint<span class='operator'>.</span>resize<span class='parenthesis'>(</span>endpoint_len<span class='parenthesis'>)</span>;
</pre>
<del >On success, <span class='texttt'>s</span> is <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span>ctx, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise,  <span class='texttt'>s</span> is  <span class='texttt'>socket_&shy;type<span class='parenthesis'>(</span>ctx<span class='parenthesis'>)</span></span>.</del>
<ins >On success, <span class='texttt'>s</span> is <span class='texttt'>S<span class='parenthesis'>(</span>ex, protocol_&shy;, h<span class='parenthesis'>)</span></span>. Otherwise,  <span class='texttt'>s</span> is  <span class='texttt'>S<span class='parenthesis'>(</span>ex<span class='parenthesis'>)</span></span>.</ins></div></div><div class='itemdecl' id='socket.acceptor.ops-itemdecl:32'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.acceptor.ops-itemdecl:32'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span></span></ins>
<ins ><span class='texttt'>  <span class='textit'><span class='texttt'>DEDUCED</span></span>&nbsp;async_&shy;accept<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx, endpoint_&shy;type<span class='operator'>&amp;</span> endpoint,</span></ins>
<ins ><span class='texttt'>                       CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Returns:</span></ins>
<pre class='codeblock'>
<ins ><span class='tcode_in_codeblock'>async_&shy;accept<span class='parenthesis'>(</span>ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span></ins>
</pre></div>
</div>

<p><em>Update the class template <code>basic_socket_streambuf</code> [socket.streambuf] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>19.1</a> Class template <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> <a class='abbr_ref' href='#'>[socket.streambuf]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class <span class='texttt'>basic_&shy;socket_&shy;streambuf<span class='anglebracket'>&lt;</span>Protocol, Clock, WaitTraits, Executor<span class='anglebracket'>&gt;</span></span> associates both the input sequence and the output sequence with a socket. The input and output sequences do not support seeking. <div id='socket.streambuf-1.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.streambuf-1.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> The input and output sequences are independent as a stream socket provides full duplex I/O. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> </div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.html#2'>2</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><div id='socket.streambuf-2.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.streambuf-2.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> This class is intended for sending and receiving bytes, not characters. Any conversion from characters to bytes, and vice versa, occurs elsewhere. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> <pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock, <span class='keyword'>class</span> WaitTraits<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_socket_streambuf <span class='operator'>:</span> <span class='keyword'>public</span> basic_streambuf<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span>
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> executor_&shy;type <span class='operator'>=</span> Executor;</span></ins>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> Protocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;
    <span class='keyword'>using</span> clock_type <span class='operator'>=</span> Clock;
    <span class='keyword'>using</span> time_point <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>time_point;
    <span class='keyword'>using</span> duration <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>duration;
    <span class='keyword'>using</span> wait_traits_type <span class='operator'>=</span> WaitTraits;

    <span class='comment'>// <a href='#socket.streambuf.cons'>[socket.streambuf.cons]</a>, construct / copy / destroy:</span>

    basic_socket_streambuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>explicit</span> basic_socket_streambuf<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> s<span class='parenthesis'>)</span>;
    basic_socket_streambuf<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_streambuf<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_streambuf<span class='parenthesis'>(</span>basic_socket_streambuf<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='keyword'>virtual</span> <span class='operator'>~</span>basic_socket_streambuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_socket_streambuf<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_streambuf<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_streambuf<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_streambuf<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='comment'>// <a href='#socket.streambuf.members'>[socket.streambuf.members]</a>, members:</span>

    basic_socket_streambuf<span class='operator'>*</span> connect<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> e<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span> basic_socket_streambuf<span class='operator'>*</span> connect<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> <span class='parenthesis'>)</span>;

    basic_socket_streambuf<span class='operator'>*</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    error_code error<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    time_point expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    <span class='keyword'>void</span> expires_at<span class='parenthesis'>(</span><span class='keyword'>const</span> time_point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> expires_after<span class='parenthesis'>(</span><span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;

  <span class='keyword'>protected</span><span class='operator'>:</span>
    <span class='comment'>// overridden virtual functions:</span>
    <span class='keyword'>virtual</span> int_type underflow<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>override</span>;
    <span class='keyword'>virtual</span> int_type pbackfail<span class='parenthesis'>(</span>int_type c <span class='operator'>=</span> traits_type<span class='operator'>::</span>eof<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> <span class='keyword'>override</span>;
    <span class='keyword'>virtual</span> int_type overflow<span class='parenthesis'>(</span>int_type c <span class='operator'>=</span> traits_type<span class='operator'>::</span>eof<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> <span class='keyword'>override</span>;
    <span class='keyword'>virtual</span> <span class='keyword'>int</span> sync<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>override</span>;
    <span class='keyword'>virtual</span> streambuf<span class='operator'>*</span> setbuf<span class='parenthesis'>(</span>char_type<span class='operator'>*</span> s, streamsize n<span class='parenthesis'>)</span> <span class='keyword'>override</span>;

  <span class='keyword'>private</span><span class='operator'>:</span>
    basic_stream_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> socket_; <span class='comment'>// <span class='textit'>exposition only</span></span>
    error_code ec_; <span class='comment'>// <span class='textit'>exposition only</span></span>
    time_point expiry_; <span class='comment'>// <span class='textit'>exposition only</span></span>
  <span class='curlybracket'>}</span>;

<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.html#3'>3</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>Instances of class template <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> meet the requirements of <span class='texttt'>Destructible</span> (C++2014[destructible]), <span class='texttt'>MoveConstructible</span> (C++2014[moveconstructible]), and <span class='texttt'>MoveAssignable</span> (C++2014[moveassignable]).</div><div id='socket.streambuf.cons' class='section'>

<div class='wording'>

<h3 ><a class='secnum' style='min-width:103pt'>19.1.1</a> <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> constructors <a class='abbr_ref' href='#'>[socket.streambuf.cons]</a></h3><div class='itemdecl' id='socket.streambuf.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes <span class='texttt'>socket_&shy;</span> with <span class='texttt'>ctx</span>, where <span class='texttt'>ctx</span> is an unspecified object of class <span class='texttt'>io_&shy;context</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> time_&shy;point<span class='operator'>&#x200b;::&#x200b;</span>max<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> and <span class='texttt'><span class='operator'>!</span>error<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, io_&shy;context<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.streambuf.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_socket_streambuf<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='texttt'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> s<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes <span class='texttt'>socket_&shy;</span> with <span class='texttt'>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>s<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> time_&shy;point<span class='operator'>&#x200b;::&#x200b;</span>max<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> and <span class='texttt'><span class='operator'>!</span>error<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.streambuf.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='parenthesis'>(</span>basic_socket_streambuf<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs from the rvalue <span class='texttt'>rhs</span>. It is <span class='indexparent'><a class='index' id=':whether_the_sequence_pointers_in_basic_socket_streambuf_obtain_the_source_object&#39;s_values_after_move-construction'></a></span>implementation-defined whether the sequence pointers in <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> (<span class='texttt'>eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, <span class='texttt'>gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, <span class='texttt'>egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, <span class='texttt'>pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, <span class='texttt'>pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, <span class='texttt'>epptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>) obtain the values which <span class='texttt'>rhs</span> had. Whether they do or not, <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> and <span class='texttt'>rhs</span> reference separate buffers (if any at all) after the construction. Additionally <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> references the socket which <span class='texttt'>rhs</span> did before the construction, and <span class='texttt'>rhs</span> references no open socket after the construction.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span>Let <span class='texttt'>rhs_&shy;p</span> refer to the state of <span class='texttt'>rhs</span> just prior to this construction and let <span class='texttt'>rhs_&shy;a</span> refer to the state of <span class='texttt'>rhs</span> just after this construction. <ul class='itemize'><li id='socket.streambuf.cons-6.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.1'>(6.1)</a></div><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.2'>(6.2)</a></div><span class='texttt'>rhs_&shy;a<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span></li><li id='socket.streambuf.cons-6.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.3'>(6.3)</a></div><span class='texttt'>error<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>error<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.4'>(6.4)</a></div><span class='texttt'><span class='operator'>!</span>rhs_&shy;a<span class='operator'>.</span>error<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.5'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.5'>(6.5)</a></div><span class='texttt'>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.6'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.6'>(6.6)</a></div><span class='texttt'>rhs_&shy;a<span class='operator'>.</span>expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> time_&shy;point<span class='operator'>&#x200b;::&#x200b;</span>max<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.7'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.7'>(6.7)</a></div><span class='texttt'>gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> rhs_&shy;p<span class='operator'>.</span>eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.8'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.8'>(6.8)</a></div><span class='texttt'>egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> rhs_&shy;p<span class='operator'>.</span>eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.9'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.9'>(6.9)</a></div><span class='texttt'>ptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> rhs_&shy;p<span class='operator'>.</span>pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.10'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.10'>(6.10)</a></div><span class='texttt'>pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs_&shy;p<span class='operator'>.</span>epptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>-</span> rhs_&shy;p<span class='operator'>.</span>pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.11'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.11'>(6.11)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>eback<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.12'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.12'>(6.12)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>gptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.13'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.13'>(6.13)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>egptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.14'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.14'>(6.14)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>pbase<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.15'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.15'>(6.15)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>pptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li><li id='socket.streambuf.cons-6.16'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.streambuf.cons-6.16'>(6.16)</a></div><span class='texttt'><span class='keyword'>if</span> <span class='parenthesis'>(</span>epptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span> epptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>!</span><span class='operator'>=</span> rhs_&shy;a<span class='operator'>.</span>epptr<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span></li></ul></div></div><div class='itemdecl' id='socket.streambuf.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>virtual</span> <span class='operator'>~</span>basic_socket_streambuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If a put area exists, calls <span class='texttt'>overflow<span class='parenthesis'>(</span>traits_&shy;type<span class='operator'>&#x200b;::&#x200b;</span>eof<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span> to flush characters. <div id='socket.streambuf.cons-7.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.streambuf.cons-7.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> The socket is closed by the <span class='texttt'>basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>protocol_&shy;type<ins >, executor_&shy;type</ins><span class='anglebracket'>&gt;</span></span> destructor. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> </div></div><div class='itemdecl' id='socket.streambuf.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_streambuf<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Calls <span class='texttt'><span class='keyword'>this</span><span class='operator'>-</span><span class='anglebracket'>&gt;</span>close<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> then move assigns from <span class='texttt'>rhs</span>. After the move assignment <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> and <span class='texttt'>rhs</span> have the observable state
they would have had if <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> had been move constructed from <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.cons.html#9'>9</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div>
</div>

</div><div id='socket.streambuf.members' class='section'>

<div class='wording'>

<h3 ><a class='secnum' style='min-width:103pt'>19.1.2</a> <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> members <a class='abbr_ref' href='#'>[socket.streambuf.members]</a></h3><div class='itemdecl' id='socket.streambuf.members-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.members-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='operator'>*</span> connect<span class='parenthesis'>(</span><span class='keyword'>const</span> endpoint_type<span class='operator'>&amp;</span> e<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> as required, closes and re-opens the socket by performing <span class='texttt'>socket_&shy;<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec_&shy;<span class='parenthesis'>)</span></span> and <span class='texttt'>socket_&shy;<span class='operator'>.</span>open<span class='parenthesis'>(</span>e<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec_&shy;<span class='parenthesis'>)</span></span>, then attempts to establish a connection as if by POSIX <span class='texttt'>connect<span class='parenthesis'>(</span>socket_&shy;<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, <span class='keyword'>static_&shy;cast</span><span class='anglebracket'>&lt;</span>sockaddr<span class='operator'>*</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>e<span class='operator'>.</span>data<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>, e<span class='operator'>.</span>size<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. <span class='texttt'>ec_&shy;</span> is set to reflect the error code produced by the operation. If the operation does not complete before the absolute timeout specified by <span class='texttt'>expiry_&shy;</span>, the socket is closed and <span class='texttt'>ec_&shy;</span> is set to <span class='texttt'>errc<span class='operator'>&#x200b;::&#x200b;</span>timed_&shy;out</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>if <span class='texttt'><span class='operator'>!</span>ec_&shy;</span>, <span class='texttt'><span class='keyword'>this</span></span>; otherwise, a null pointer.</div></div><div class='itemdecl' id='socket.streambuf.members-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.members-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
  basic_socket_streambuf<span class='operator'>*</span> connect<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the <span class='texttt'>basic_&shy;socket_&shy;streambuf</span> as required and closes the socket as if by calling <span class='texttt'>socket_&shy;<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec_&shy;<span class='parenthesis'>)</span></span>. Obtains an endpoint sequence <span class='texttt'>endpoints</span> by performing <span class='texttt'>protocol_&shy;type<span class='operator'>&#x200b;::&#x200b;</span>resolver<span class='parenthesis'>(</span>ctx<span class='parenthesis'>)</span><span class='operator'>.</span>resolve<span class='parenthesis'>(</span>forward<span class='anglebracket'>&lt;</span>Args<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>args<span class='parenthesis'>)</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span></span>, where <span class='texttt'>ctx</span> is an unspecified object of class <span class='texttt'>io_&shy;context</span>. For each endpoint <span class='texttt'>e</span> in the sequence, closes and re-opens the socket by performing <span class='texttt'>socket_&shy;<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec_&shy;<span class='parenthesis'>)</span></span> and <span class='texttt'>socket_&shy;<span class='operator'>.</span>open<span class='parenthesis'>(</span>e<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec_&shy;<span class='parenthesis'>)</span></span>, then attempts to establish a connection as if by POSIX <span class='texttt'>connect<span class='parenthesis'>(</span>socket_&shy;<span class='operator'>.</span>native_&shy;handle<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, <span class='keyword'>static_&shy;cast</span><span class='anglebracket'>&lt;</span>sockaddr<span class='operator'>*</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>e<span class='operator'>.</span>data<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span>, e<span class='operator'>.</span>size<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>. <span class='texttt'>ec_&shy;</span> is set to reflect the error code produced by the operation. If the operation does not complete before the absolute timeout specified by <span class='texttt'>expiry_&shy;</span>, the socket is closed and <span class='texttt'>ec_&shy;</span> is set to <span class='texttt'>errc<span class='operator'>&#x200b;::&#x200b;</span>timed_&shy;out</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>if <span class='texttt'><span class='operator'>!</span>ec_&shy;</span>, <span class='texttt'><span class='keyword'>this</span></span>; otherwise, a null pointer.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless <span class='texttt'>Protocol</span> meets the requirements for an internet protocol (<a href='#internet.reqmts.protocol'>[internet.reqmts.protocol]</a>).</div></div><div class='itemdecl' id='socket.streambuf.members-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.members-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='operator'>*</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>If a put area exists, calls <span class='texttt'>overflow<span class='parenthesis'>(</span>traits_&shy;type<span class='operator'>&#x200b;::&#x200b;</span>eof<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='parenthesis'>)</span></span> to flush characters. Regardless of whether the preceding call fails or throws an exception, the function closes the socket as if by <span class='texttt'>basic_&shy;socket<span class='anglebracket'>&lt;</span>protocol_&shy;type<ins >, executor_&shy;type</ins><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>close<span class='parenthesis'>(</span>ec_&shy;<span class='parenthesis'>)</span></span>. If any of the calls made by the function fail, <span class='texttt'>close</span> fails by returning a null pointer. If one of these calls throws an exception, the exception is caught and rethrown after closing the socket.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='keyword'>this</span></span> on success, a null pointer otherwise.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span>.</div></div><div class='itemdecl' id='socket.streambuf.members-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.streambuf.members-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='texttt'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.streambuf.members.html#9'>9</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>socket_&shy;</span>.</div></div>
</div>
</div>
</div>

<p><em>Update the class template <code>basic_socket_iostream</code> [socket.iostream] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>19.2</a> Class template <span class='texttt'>basic_&shy;socket_&shy;iostream</span> <a class='abbr_ref' href='#'>[socket.iostream]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class template <span class='texttt'>basic_&shy;socket_&shy;iostream<span class='anglebracket'>&lt;</span>Protocol, Clock, WaitTraits, Executor<span class='anglebracket'>&gt;</span></span> supports reading and writing on sockets. It uses a <span class='texttt'>basic_&shy;socket_&shy;streambuf<span class='anglebracket'>&lt;</span>Protocol, Clock, WaitTraits, Executor<span class='anglebracket'>&gt;</span></span> object to control the associated sequences.</div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.html#2'>2</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><div id='socket.iostream-2.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.iostream-2.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> This class is intended for sending and receiving bytes, not characters. Any conversion from characters to bytes, and vice versa, occurs elsewhere. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> <pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol, <span class='keyword'>class</span> Clock, <span class='keyword'>class</span> WaitTraits<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_socket_iostream <span class='operator'>:</span> <span class='keyword'>public</span> basic_iostream<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span>
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> executor_&shy;type <span class='operator'>=</span> Executor;</span></ins>
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> Protocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> protocol_type<span class='operator'>::</span>endpoint;
    <span class='keyword'>using</span> clock_type <span class='operator'>=</span> Clock;
    <span class='keyword'>using</span> time_point <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>time_point;
    <span class='keyword'>using</span> duration <span class='operator'>=</span> <span class='keyword'>typename</span> clock_type<span class='operator'>::</span>duration;
    <span class='keyword'>using</span> wait_traits_type <span class='operator'>=</span> WaitTraits;

    <span class='comment'>// <a href='#socket.iostream.cons'>[socket.iostream.cons]</a>, construct / copy / destroy:</span>

    basic_socket_iostream<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    <span class='keyword'>explicit</span> basic_socket_iostream<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> s<span class='parenthesis'>)</span>;
    basic_socket_iostream<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_iostream<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_iostream<span class='parenthesis'>(</span>basic_socket_iostream<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
      <span class='keyword'>explicit</span> basic_socket_iostream<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;

    basic_socket_iostream<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> basic_socket_iostream<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_socket_iostream<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_iostream<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;

    <span class='comment'>// <a href='#socket.iostream.members'>[socket.iostream.members]</a>, members:</span>

    <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span> <span class='keyword'>void</span> connect<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;

    <span class='keyword'>void</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;

    basic_socket_streambuf<span class='anglebracket'>&lt;</span>protocol_type, clock_type, wait_traits_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>*</span> rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    basic_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
    error_code error<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;

    time_point expiry<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
    <span class='keyword'>void</span> expires_at<span class='parenthesis'>(</span><span class='keyword'>const</span> time_point<span class='operator'>&amp;</span> t<span class='parenthesis'>)</span>;
    <span class='keyword'>void</span> expires_after<span class='parenthesis'>(</span><span class='keyword'>const</span> duration<span class='operator'>&amp;</span> d<span class='parenthesis'>)</span>;

  <span class='keyword'>private</span><span class='operator'>:</span>
    basic_socket_streambuf<span class='anglebracket'>&lt;</span>protocol_type, clock_type, wait_traits_type<ins ><span class='tcode_in_codeblock'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> sb_; <span class='comment'>// <span class='textit'>exposition only</span></span>
  <span class='curlybracket'>}</span>;

<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.html#3'>3</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>Instances of class template <span class='texttt'>basic_&shy;socket_&shy;iostream</span> meet the requirements of <span class='texttt'>Destructible</span> (C++2014[destructible]), <span class='texttt'>MoveConstructible</span> (C++2014[moveconstructible]), and <span class='texttt'>MoveAssignable</span> (C++2014[moveassignable]).</div><div id='socket.iostream.cons' class='section'>

<div class='wording'>

<h3 ><a class='secnum' style='min-width:103pt'>19.2.1</a> <span class='texttt'>basic_&shy;socket_&shy;iostream</span> constructors <a class='abbr_ref' href='#'>[socket.iostream.cons]</a></h3><div class='itemdecl' id='socket.iostream.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'>basic_socket_iostream<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class as <span class='texttt'>basic_&shy;iostream<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span><span class='operator'>&amp;</span>sb_&shy;<span class='parenthesis'>)</span></span>, value-initializes <span class='texttt'>sb_&shy;</span>, and performs <span class='texttt'>setf<span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>ios_&shy;base<span class='operator'>&#x200b;::&#x200b;</span>unitbuf<span class='parenthesis'>)</span></span>.</div></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;default_&shy;constructible<span class='anglebracket'>&lt;</span>basic_&shy;socket_&shy;streambuf<span class='anglebracket'>&lt;</span>protocol_&shy;type, clock_&shy;type, wait_&shy;traits_&shy;type, executor_&shy;type<span class='anglebracket'>&gt;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='socket.iostream.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_socket_iostream<span class='parenthesis'>(</span>basic_stream_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='texttt'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span> s<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class as <span class='texttt'>basic_&shy;iostream<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span><span class='operator'>&amp;</span>sb_&shy;<span class='parenthesis'>)</span></span>, initializes <span class='texttt'>sb_&shy;</span> with <span class='texttt'>std<span class='operator'>&#x200b;::&#x200b;</span>move<span class='parenthesis'>(</span>s<span class='parenthesis'>)</span></span>, and performs <span class='texttt'>setf<span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>ios_&shy;base<span class='operator'>&#x200b;::&#x200b;</span>unitbuf<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.iostream.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket_iostream<span class='parenthesis'>(</span>basic_socket_iostream<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs from the rvalue <span class='texttt'>rhs</span>. This is accomplished by move constructing the base class, and the contained <span class='texttt'>basic_&shy;socket_&shy;streambuf</span>. Next <span class='texttt'>basic_&shy;iostream<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>set_&shy;rdbuf<span class='parenthesis'>(</span><span class='operator'>&amp;</span>sb_&shy;<span class='parenthesis'>)</span></span> is called to install the contained <span class='texttt'>basic_&shy;socket_&shy;streambuf</span>.</div></div><div class='itemdecl' id='socket.iostream.cons-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.cons-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
  <span class='keyword'>explicit</span> basic_socket_iostream<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Initializes the base class as <span class='texttt'>basic_&shy;iostream<span class='anglebracket'>&lt;</span><span class='keyword'>char</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span><span class='operator'>&amp;</span>sb_&shy;<span class='parenthesis'>)</span></span>, value-initializes <span class='texttt'>sb_&shy;</span>, and performs <span class='texttt'>setf<span class='parenthesis'>(</span>std<span class='operator'>&#x200b;::&#x200b;</span>ios_&shy;base<span class='operator'>&#x200b;::&#x200b;</span>unitbuf<span class='parenthesis'>)</span></span>. Then calls <span class='texttt'>rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='operator'>-</span><span class='anglebracket'>&gt;</span>connect<span class='parenthesis'>(</span>forward<span class='anglebracket'>&lt;</span>Args<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>args<span class='parenthesis'>)</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span></span>. If that function returns a null pointer, calls <span class='texttt'>setstate<span class='parenthesis'>(</span>failbit<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.iostream.cons-itemdecl:5'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.cons-itemdecl:5'>🔗</a></div><pre class='itemdeclcode'>basic_socket_iostream<span class='operator'>&amp;</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='parenthesis'>(</span>basic_socket_iostream<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move assigns the base and members of <span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span> from the base and corresponding members of <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.cons.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='operator'>*</span><span class='keyword'>this</span></span>.</div></div>

</div>

</div><div id='socket.iostream.members' class='section'>

<div class='wording'>

<h3 ><a class='secnum' style='min-width:103pt'>19.2.2</a> <span class='texttt'>basic_&shy;socket_&shy;iostream</span> members <a class='abbr_ref' href='#'>[socket.iostream.members]</a></h3><div class='itemdecl' id='socket.iostream.members-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.members-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> Args<span class='anglebracket'>&gt;</span>
  <span class='keyword'>void</span> connect<span class='parenthesis'>(</span>Args<span class='operator'>&amp;</span><span class='operator'>&amp;</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span> args<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.members.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Calls <span class='texttt'>rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='operator'>-</span><span class='anglebracket'>&gt;</span>connect<span class='parenthesis'>(</span>forward<span class='anglebracket'>&lt;</span>Args<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>args<span class='parenthesis'>)</span><span class='operator'>.</span><span class='operator'>.</span><span class='operator'>.</span><span class='parenthesis'>)</span></span>. If that function returns a null pointer, calls <span class='texttt'>setstate<span class='parenthesis'>(</span>failbit<span class='parenthesis'>)</span></span> (which may throw <span class='texttt'>ios_&shy;base<span class='operator'>&#x200b;::&#x200b;</span>failure</span>).</div></div><div class='itemdecl' id='socket.iostream.members-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.members-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>void</span> close<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.members.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Calls <span class='texttt'>rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='operator'>-</span><span class='anglebracket'>&gt;</span>close<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>. If that function returns a null pointer, calls <span class='texttt'>setstate<span class='parenthesis'>(</span>failbit<span class='parenthesis'>)</span></span> (which may throw <span class='texttt'>ios_&shy;base<span class='operator'>&#x200b;::&#x200b;</span>failure</span>).</div></div><div class='itemdecl' id='socket.iostream.members-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.members-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_socket_streambuf<span class='anglebracket'>&lt;</span>protocol_type, clock_type, wait_traits_type<ins ><span class='texttt'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>*</span> rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>const</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.members.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>Let <span class='texttt'>SB</span> be the type <span class='texttt'>basic_&shy;socket_&shy;streambuf<span class='anglebracket'>&lt;</span>protocol_&shy;type, clock_&shy;type, wait_&shy;traits_&shy;type<ins >, executor_&shy;type</ins><span class='anglebracket'>&gt;</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.members.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='keyword'>const_&shy;cast</span><span class='anglebracket'>&lt;</span>SB<span class='operator'>*</span><span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>addressof<span class='parenthesis'>(</span>sb_&shy;<span class='parenthesis'>)</span><span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.iostream.members-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.iostream.members-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'>basic_socket<span class='anglebracket'>&lt;</span>protocol_type<ins ><span class='texttt'>, executor_&shy;type</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.iostream.members.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>rdbuf<span class='parenthesis'>(</span><span class='parenthesis'>)</span><span class='operator'>-</span><span class='anglebracket'>&gt;</span>socket<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</div></div>
</div>
</div>
</div>

<p><em>Update the <code>connect</code> function [socket.algo.connect] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>20.1</a> Synchronous connect operations <a class='abbr_ref' href='#'>[socket.algo.connect]</a></h2><div class='itemdecl' id='socket.algo.connect-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.connect-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence<span class='anglebracket'>&gt;</span>
  <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                      <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints<span class='parenthesis'>)</span>;
<span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence<span class='anglebracket'>&gt;</span>
  <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                      <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                      error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>connect<span class='parenthesis'>(</span>s, endpoints, <span class='squarebracket'>[</span><span class='squarebracket'>]</span><span class='parenthesis'>(</span><span class='keyword'>auto</span>, <span class='keyword'>auto</span><span class='parenthesis'>)</span><span class='curlybracket'>{</span> <span class='keyword'>return</span> <span class='literal'>true</span>; <span class='curlybracket'>}</span>, ec<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.algo.connect-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.connect-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
  <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                      <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                      ConnectCondition c<span class='parenthesis'>)</span>;
<span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
  <span class='keyword'>typename</span> Protocol<span class='operator'>::</span>endpoint connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                                      <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                                      ConnectCondition c, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Performs <span class='texttt'>ec<span class='operator'>.</span>clear<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, then finds the first element <span class='texttt'>ep</span> in the sequence <span class='texttt'>endpoints</span> for which:
<ul class='itemize'><li id='socket.algo.connect-2.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-2.1'>(2.1)</a></div><span class='texttt'>c<span class='parenthesis'>(</span>ec, ep<span class='parenthesis'>)</span></span> yields <span class='texttt'><span class='literal'>true</span></span>;</li><li id='socket.algo.connect-2.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-2.2'>(2.2)</a></div><span class='texttt'>s<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec<span class='parenthesis'>)</span></span> succeeds;</li><li id='socket.algo.connect-2.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-2.3'>(2.3)</a></div><span class='texttt'>s<span class='operator'>.</span>open<span class='parenthesis'>(</span>ep<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec<span class='parenthesis'>)</span></span> succeeds; and</li><li id='socket.algo.connect-2.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-2.4'>(2.4)</a></div><span class='texttt'>s<span class='operator'>.</span>connect<span class='parenthesis'>(</span>ep, ec<span class='parenthesis'>)</span></span> succeeds.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'><span class='keyword'>typename</span> Protocol<span class='operator'>&#x200b;::&#x200b;</span>endpoint<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> if no such element is found, otherwise <span class='texttt'>ep</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Error conditions:</span>
<ul class='itemize'><li id='socket.algo.connect-4.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-4.1'>(4.1)</a></div><span class='texttt'>socket_&shy;errc<span class='operator'>&#x200b;::&#x200b;</span>not_&shy;found</span> &mdash; if <span class='texttt'>endpoints<span class='operator'>.</span>empty<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> or if the function object <span class='texttt'>c</span> returned <span class='texttt'><span class='literal'>false</span></span> for all elements in the sequence.</li></ul></div></div><div class='itemdecl' id='socket.algo.connect-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.connect-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator<span class='anglebracket'>&gt;</span>
  InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        InputIterator first, InputIterator last<span class='parenthesis'>)</span>;
<span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator<span class='anglebracket'>&gt;</span>
  InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        InputIterator first, InputIterator last,
                        error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>connect<span class='parenthesis'>(</span>s, first, last, <span class='squarebracket'>[</span><span class='squarebracket'>]</span><span class='parenthesis'>(</span><span class='keyword'>auto</span>, <span class='keyword'>auto</span><span class='parenthesis'>)</span><span class='curlybracket'>{</span> <span class='keyword'>return</span> <span class='literal'>true</span>; <span class='curlybracket'>}</span>, ec<span class='parenthesis'>)</span></span>.</div></div><div class='itemdecl' id='socket.algo.connect-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.connect-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
  InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        InputIterator first, InputIterator last,
                        ConnectCondition c<span class='parenthesis'>)</span>;
<span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> ConnectCondition<span class='anglebracket'>&gt;</span>
  InputIterator connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        InputIterator first, InputIterator last,
                        ConnectCondition c, error_code<span class='operator'>&amp;</span> ec<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Performs <span class='texttt'>ec<span class='operator'>.</span>clear<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, then finds the first iterator <span class='texttt'>i</span> in the range <span class='texttt'><span class='squarebracket'>[</span>first,<span class='operator'> </span>&#x200b;last<span class='parenthesis'>)</span></span> for which:
<ul class='itemize'><li id='socket.algo.connect-6.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-6.1'>(6.1)</a></div><span class='texttt'>c<span class='parenthesis'>(</span>ec, <span class='operator'>*</span>i<span class='parenthesis'>)</span></span> yields <span class='texttt'><span class='literal'>true</span></span>;</li><li id='socket.algo.connect-6.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-6.2'>(6.2)</a></div><span class='texttt'>s<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec<span class='parenthesis'>)</span></span> succeeds;</li><li id='socket.algo.connect-6.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-6.3'>(6.3)</a></div><span class='texttt'>s<span class='operator'>.</span>open<span class='parenthesis'>(</span><span class='keyword'>typename</span> Protocol<span class='operator'>&#x200b;::&#x200b;</span>endpoint<span class='parenthesis'>(</span><span class='operator'>*</span>i<span class='parenthesis'>)</span><span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec<span class='parenthesis'>)</span></span> succeeds; and</li><li id='socket.algo.connect-6.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-6.4'>(6.4)</a></div><span class='texttt'>s<span class='operator'>.</span>connect<span class='parenthesis'>(</span><span class='operator'>*</span>i, ec<span class='parenthesis'>)</span></span> succeeds.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span><span class='texttt'>last</span> if no such iterator is found, otherwise <span class='texttt'>i</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.connect.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Error conditions:</span>
<ul class='itemize'><li id='socket.algo.connect-8.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.connect-8.1'>(8.1)</a></div><span class='texttt'>socket_&shy;errc<span class='operator'>&#x200b;::&#x200b;</span>not_&shy;found</span> &mdash; if <span class='texttt'>first <span class='operator'>=</span><span class='operator'>=</span> last</span> or if the function object <span class='texttt'>c</span> returned <span class='texttt'><span class='literal'>false</span></span> for all iterators in the range.</li></ul></div></div>
</div>

<p><em>Update the <code>async_connect</code> function [socket.algo.async.connect] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>20.2</a> Asynchronous connect operations <a class='abbr_ref' href='#'>[socket.algo.async.connect]</a></h2><div class='itemdecl' id='socket.algo.async.connect-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.async.connect-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
  <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                        CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>
<pre class='codeblock'>
async_connect<span class='parenthesis'>(</span>s, endpoints, <span class='squarebracket'>[</span><span class='squarebracket'>]</span><span class='parenthesis'>(</span><span class='keyword'>auto</span>, <span class='keyword'>auto</span><span class='parenthesis'>)</span><span class='curlybracket'>{</span> <span class='keyword'>return</span> <span class='literal'>true</span>; <span class='curlybracket'>}</span>, forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span>
</pre></div></div><div class='itemdecl' id='socket.algo.async.connect-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.async.connect-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> EndpointSequence,
  <span class='keyword'>class</span> ConnectCondition, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          <span class='keyword'>const</span> EndpointSequence<span class='operator'>&amp;</span> endpoints,
                          ConnectCondition c,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>A composed asynchronous operation (<a href='#async.reqmts.async.composed'>[async.reqmts.async.composed]</a>).</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Completion signature:</span><span class='texttt'><span class='keyword'>void</span><span class='parenthesis'>(</span>error_&shy;code ec, <span class='keyword'>typename</span> Protocol<span class='operator'>&#x200b;::&#x200b;</span>endpoint ep<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#4'>4</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Performs <span class='texttt'>ec<span class='operator'>.</span>clear<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, then finds the first element <span class='texttt'>ep</span> in the sequence <span class='texttt'>endpoints</span> for which:
<ul class='itemize'><li id='socket.algo.async.connect-4.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-4.1'>(4.1)</a></div><span class='texttt'>c<span class='parenthesis'>(</span>ec, ep<span class='parenthesis'>)</span></span> yields <span class='texttt'><span class='literal'>true</span></span>;</li><li id='socket.algo.async.connect-4.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-4.2'>(4.2)</a></div><span class='texttt'>s<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec<span class='parenthesis'>)</span></span> succeeds;</li><li id='socket.algo.async.connect-4.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-4.3'>(4.3)</a></div><span class='texttt'>s<span class='operator'>.</span>open<span class='parenthesis'>(</span>ep<span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec<span class='parenthesis'>)</span></span> succeeds; and</li><li id='socket.algo.async.connect-4.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-4.4'>(4.4)</a></div>the asynchronous operation <span class='texttt'>s<span class='operator'>.</span>async_&shy;connect<span class='parenthesis'>(</span>ep, <span class='textit'><span class='texttt'>unspecified</span></span><span class='parenthesis'>)</span></span> succeeds.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#5'>5</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='texttt'>ec</span> is updated with the result of the <span class='texttt'>s<span class='operator'>.</span>async_&shy;connect<span class='parenthesis'>(</span>ep, <span class='textit'><span class='texttt'>unspecified</span></span><span class='parenthesis'>)</span></span> operation, if any. If no such element is found, or if the operation fails with one of the error conditions listed below, <span class='texttt'>ep</span> is set to <span class='texttt'><span class='keyword'>typename</span> Protocol<span class='operator'>&#x200b;::&#x200b;</span>endpoint<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>. <div id='socket.algo.async.connect-5.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.algo.async.connect-5.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> The underlying <span class='texttt'>close</span>, <span class='texttt'>open</span>, and <span class='texttt'>async_&shy;connect</span> operations are performed sequentially. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> </div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#6'>6</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Error conditions:</span>
<ul class='itemize'><li id='socket.algo.async.connect-6.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-6.1'>(6.1)</a></div><span class='texttt'>socket_&shy;errc<span class='operator'>&#x200b;::&#x200b;</span>not_&shy;found</span> &mdash; if <span class='texttt'>endpoints<span class='operator'>.</span>empty<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span> or if the function object <span class='texttt'>c</span> returned <span class='texttt'><span class='literal'>false</span></span> for all elements in the sequence.</li><li id='socket.algo.async.connect-6.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-6.2'>(6.2)</a></div><span class='texttt'>errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> &mdash; if <span class='texttt'>s<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span> immediately following an <span class='texttt'>async_&shy;connect</span> operation on the underlying socket.</li></ul></div></div><div class='itemdecl' id='socket.algo.async.connect-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.async.connect-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
  <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                        InputIterator first, InputIterator last,
                        CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#7'>7</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Returns:</span>
<pre class='codeblock'>
async_connect<span class='parenthesis'>(</span>s, first, last, <span class='squarebracket'>[</span><span class='squarebracket'>]</span><span class='parenthesis'>(</span><span class='keyword'>auto</span>, <span class='keyword'>auto</span><span class='parenthesis'>)</span><span class='curlybracket'>{</span> <span class='keyword'>return</span> <span class='literal'>true</span>; <span class='curlybracket'>}</span>,
              forward<span class='anglebracket'>&lt;</span>CompletionToken<span class='anglebracket'>&gt;</span><span class='parenthesis'>(</span>token<span class='parenthesis'>)</span><span class='parenthesis'>)</span>
</pre></div></div><div class='itemdecl' id='socket.algo.async.connect-itemdecl:4'><div class='marginalizedparent'><a class='itemDeclLink' href='#socket.algo.async.connect-itemdecl:4'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Protocol<ins ><span class='texttt'>, <span class='keyword'>class</span> Executor</span></ins>, <span class='keyword'>class</span> InputIterator,
  <span class='keyword'>class</span> ConnectCondition, <span class='keyword'>class</span> CompletionToken<span class='anglebracket'>&gt;</span>
    <span class='textit'><span class='texttt'>DEDUCED</span></span> async_connect<span class='parenthesis'>(</span>basic_socket<span class='anglebracket'>&lt;</span>Protocol<ins ><span class='texttt'>, Executor</span></ins><span class='anglebracket'>&gt;</span><span class='operator'>&amp;</span> s,
                          InputIterator first, InputIterator last,
                          ConnectCondition c,
                          CompletionToken<span class='operator'>&amp;</span><span class='operator'>&amp;</span> token<span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#8'>8</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>A composed asynchronous operation (<a href='#async.reqmts.async.composed'>[async.reqmts.async.composed]</a>).</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#9'>9</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Completion signature:</span><span class='texttt'><span class='keyword'>void</span><span class='parenthesis'>(</span>error_&shy;code ec, InputIterator i<span class='parenthesis'>)</span></span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#10'>10</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Performs <span class='texttt'>ec<span class='operator'>.</span>clear<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>, then finds the first iterator <span class='texttt'>i</span> in the range <span class='texttt'><span class='squarebracket'>[</span>first,<span class='operator'> </span>&#x200b;last<span class='parenthesis'>)</span></span> for which:
<ul class='itemize'><li id='socket.algo.async.connect-10.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-10.1'>(10.1)</a></div><span class='texttt'>c<span class='parenthesis'>(</span>ec, <span class='operator'>*</span>i<span class='parenthesis'>)</span></span> yields <span class='texttt'><span class='literal'>true</span></span>;</li><li id='socket.algo.async.connect-10.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-10.2'>(10.2)</a></div><span class='texttt'>s<span class='operator'>.</span>close<span class='parenthesis'>(</span>ec<span class='parenthesis'>)</span></span> succeeds;</li><li id='socket.algo.async.connect-10.3'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-10.3'>(10.3)</a></div><span class='texttt'>s<span class='operator'>.</span>open<span class='parenthesis'>(</span><span class='keyword'>typename</span> Protocol<span class='operator'>&#x200b;::&#x200b;</span>endpoint<span class='parenthesis'>(</span><span class='operator'>*</span>i<span class='parenthesis'>)</span><span class='operator'>.</span>protocol<span class='parenthesis'>(</span><span class='parenthesis'>)</span>, ec<span class='parenthesis'>)</span></span> succeeds; and</li><li id='socket.algo.async.connect-10.4'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-10.4'>(10.4)</a></div>the asynchronous operation <span class='texttt'>s<span class='operator'>.</span>async_&shy;connect<span class='parenthesis'>(</span><span class='operator'>*</span>i, <span class='textit'><span class='texttt'>unspecified</span></span><span class='parenthesis'>)</span></span> succeeds.</li></ul></div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#11'>11</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='texttt'>ec</span> is updated with the result of the <span class='texttt'>s<span class='operator'>.</span>async_&shy;connect<span class='parenthesis'>(</span><span class='operator'>*</span>i, <span class='textit'><span class='texttt'>unspecified</span></span><span class='parenthesis'>)</span></span> operation, if any. If no such iterator is found, or if the operation fails with one of the error conditions listed below, <span class='texttt'>i</span> is set to <span class='texttt'>last</span>. <div id='socket.algo.async.connect-11.note-1' class='note'>[&nbsp;<a class='note_link' href='#socket.algo.async.connect-11.note-1'><span class='textit'>Note</span></a><div class='noteBody'><span class='textit'>:</span> The underlying <span class='texttt'>close</span>, <span class='texttt'>open</span>, and <span class='texttt'>async_&shy;connect</span> operations are performed sequentially. &mdash;&nbsp;<i>end note</i></div>&nbsp;]</div> </div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='socket.algo.async.connect.html#12'>12</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Error conditions:</span>
<ul class='itemize'><li id='socket.algo.async.connect-12.1'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-12.1'>(12.1)</a></div><span class='texttt'>socket_&shy;errc<span class='operator'>&#x200b;::&#x200b;</span>not_&shy;found</span> &mdash; if <span class='texttt'>first <span class='operator'>=</span><span class='operator'>=</span> last</span> or if the function object <span class='texttt'>c</span> returned <span class='texttt'><span class='literal'>false</span></span> for all iterators in the range.</li><li id='socket.algo.async.connect-12.2'><div class='marginalizedparent' style='left:-10em'><a class='marginalized' href='#socket.algo.async.connect-12.2'>(12.2)</a></div><span class='texttt'>errc<span class='operator'>&#x200b;::&#x200b;</span>operation_&shy;canceled</span> &mdash; if <span class='texttt'>s<span class='operator'>.</span>is_&shy;open<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <span class='literal'>false</span></span> immediately following an <span class='texttt'>async_&shy;connect</span> operation on the underlying socket.</li></ul></div></div>
</div>

<p><em>Update the <code>&lt;experimental/internet&gt;</code> synopsis [internet.synop] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>21.1</a> Header <span class='texttt'>&lt;experimental/internet&gt;</span> synopsis <a class='abbr_ref' href='#'>[internet.synop]</a></h2><span class='indexparent'><a class='index' id='lib:resolver_errc'></a></span><span class='indexparent'><a class='index' id='lib:port_type'></a></span><span class='indexparent'><a class='index' id='lib:scope_id_type'></a></span><span class='indexparent'><a class='index' id='lib:v4_mapped_t'></a></span><span class='indexparent'><a class='index' id='lib:v4_mapped'></a></span>
</div>
<p><em>[...]</em></p>
<div class='wording'>
<pre class='codeblock'>
  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
    <span class='keyword'>class</span> basic_resolver;
</pre>
</div>

<p><em>Update the class template <code>basic_resolver</code> [internet.resolver] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>21.17</a> Class template <span class='texttt'>ip&#x200b;::&#x200b;basic_&shy;resolver</span> <a class='abbr_ref' href='#'>[internet.resolver]</a></h2><div class='para'><div class='marginalizedparent'><a class='marginalized' href='internet.resolver.html#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>Objects of type <span class='texttt'>basic_&shy;resolver<span class='anglebracket'>&lt;</span>InternetProtocol, Executor<span class='anglebracket'>&gt;</span></span> are used to perform name resolution. Name resolution is the translation of a host name and service name into a sequence of endpoints, or the translation of an endpoint into its corresponding host name and service name.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> ip <span class='curlybracket'>{</span>

  <span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> InternetProtocol<ins ><span class='tcode_in_codeblock'>, <span class='keyword'>class</span> Executor <span class='operator'>=</span> executor</span></ins><span class='anglebracket'>&gt;</span>
  <span class='keyword'>class</span> basic_resolver <span class='operator'>:</span> <span class='keyword'>public</span> resolver_base
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>

    <span class='keyword'>using</span> executor_type <span class='operator'>=</span> <del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type</span></del><ins ><span class='tcode_in_codeblock'>Executor</span></ins>;
    <span class='keyword'>using</span> protocol_type <span class='operator'>=</span> InternetProtocol;
    <span class='keyword'>using</span> endpoint_type <span class='operator'>=</span> <span class='keyword'>typename</span> InternetProtocol<span class='operator'>::</span>endpoint;
    <span class='keyword'>using</span> results_type <span class='operator'>=</span> basic_resolver_results<span class='anglebracket'>&lt;</span>InternetProtocol<span class='anglebracket'>&gt;</span>;

    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> OtherExecutor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>using</span> rebind_&shy;executor <span class='operator'>=</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  basic_&shy;resolver<span class='anglebracket'>&lt;</span>InternetProtocol, OtherExecutor<span class='anglebracket'>&gt;</span>;</span></ins>

    <span class='comment'>// <a href='#internet.resolver.cons'>[internet.resolver.cons]</a>, construct / copy / destroy:</span>

    <span class='keyword'>explicit</span> basic_resolver<span class='parenthesis'>(</span><del ><span class='tcode_in_codeblock'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='tcode_in_codeblock'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span> <span class='keyword'>explicit</span> basic_&shy;resolver<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
    basic_resolver<span class='parenthesis'>(</span><span class='keyword'>const</span> basic_resolver<span class='operator'>&amp;</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
    basic_resolver<span class='parenthesis'>(</span>basic_resolver<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
</pre></div>
</div>

<p><em>Update the <code>basic_resolver</code> constructors [internet.resolver.cons] as follows:</em></p>

<div class='wording'>
<h3 ><a class='secnum' style='min-width:103pt'>21.17.1</a> <span class='texttt'>ip&#x200b;::&#x200b;basic_&shy;resolver</span> constructors <a class='abbr_ref' href='#'>[internet.resolver.cons]</a></h3><div class='itemdecl' id='internet.resolver.cons-itemdecl:1'><div class='marginalizedparent'><a class='itemDeclLink' href='#internet.resolver.cons-itemdecl:1'>🔗</a></div><pre class='itemdeclcode'><span class='keyword'>explicit</span> basic_resolver<span class='parenthesis'>(</span><del ><span class='texttt'>io_&shy;context<span class='operator'>&amp;</span> ctx</span></del><ins ><span class='texttt'><span class='keyword'>const</span> executor_&shy;type<span class='operator'>&amp;</span> ex</span></ins><span class='parenthesis'>)</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='internet.resolver.cons.html#1'>1</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> <del >ctx.get_executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></del><ins >ex</ins></span>.</div></div><div class='itemdecl' id='internet.resolver.cons-itemdecl:2'><div class='marginalizedparent'><a class='itemDeclLink' href='#internet.resolver.cons-itemdecl:2'>🔗</a></div><pre class='itemdeclcode'><ins ><span class='texttt'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> ExecutionContext<span class='anglebracket'>&gt;</span> <span class='keyword'>explicit</span> basic_&shy;resolver<span class='parenthesis'>(</span>ExecutionContext<span class='operator'>&amp;</span> ctx<span class='parenthesis'>)</span>;</span></ins>
</pre></div><div class='itemdescr'></div><div class='itemdescr'><ins ><span class='textit'>Postconditions:</span><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> ctx<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</ins></div><div class='itemdescr'><ins ><span class='textit'>Remarks:</span>This function shall not participate in overload resolution unless
<span class='texttt'>is_&shy;convertible<span class='anglebracket'>&lt;</span>ExecutionContext<span class='operator'>&amp;</span>, execution_&shy;context<span class='operator'>&amp;</span><span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>
and <span class='texttt'>is_&shy;constructible<span class='anglebracket'>&lt;</span>executor_&shy;type, <span class='keyword'>typename</span> ExecutionContext<span class='operator'>&#x200b;::&#x200b;</span>executor_&shy;type<span class='anglebracket'>&gt;</span><span class='operator'>&#x200b;::&#x200b;</span>value</span> is <span class='texttt'><span class='literal'>true</span></span>.</ins></div><div class='itemdecl' id='internet.resolver.cons-itemdecl:3'><div class='marginalizedparent'><a class='itemDeclLink' href='#internet.resolver.cons-itemdecl:3'>🔗</a></div><pre class='itemdeclcode'>basic_resolver<span class='parenthesis'>(</span>basic_resolver<span class='operator'>&amp;</span><span class='operator'>&amp;</span> rhs<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
</pre></div><div class='itemdescr'></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='internet.resolver.cons.html#2'>2</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Effects:</span>Move constructs an object of class <span class='texttt'>basic_&shy;resolver<span class='anglebracket'>&lt;</span>InternetProtocol<span class='anglebracket'>&gt;</span></span> that refers to the state originally represented by <span class='texttt'>rhs</span>.</div></div><div class='para'><div class='marginalizedparent'><a class='marginalized' href='internet.resolver.cons.html#3'>3</a></div><div class='itemdescr'><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div><span class='textit'>Postconditions:</span><span class='texttt'>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span><span class='operator'>=</span> rhs<span class='operator'>.</span>get_&shy;executor<span class='parenthesis'>(</span><span class='parenthesis'>)</span></span>.</div></div>
</div>

<div class="changed">

<p><em>Update the <code>ip::tcp</code> synopsis [internet.tcp] as follows:</em></p>

<div class="wording">
<h2 ><a class='secnum' style='min-width:88pt'>21.19</a> Class <span class='texttt'>ip&#x200b;::&#x200b;tcp</span> <a class='abbr_ref'>[internet.tcp]</a></h2><div class='para' id='1'><div class='marginalizedparent'><a class='marginalized' href='#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class <span class='texttt'>tcp</span> encapsulates the types and flags necessary for TCP sockets.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> ip <span class='curlybracket'>{</span>

  <span class='keyword'>class</span> tcp
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>
    <span class='keyword'>using</span> endpoint <span class='operator'>=</span> basic_endpoint<span class='anglebracket'>&lt;</span>tcp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> resolver <span class='operator'>=</span> basic_resolver<span class='anglebracket'>&lt;</span>tcp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> socket <span class='operator'>=</span> basic_stream_socket<span class='anglebracket'>&lt;</span>tcp<span class='anglebracket'>&gt;</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Executor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>using</span> socket_&shy;for <span class='operator'>=</span> basic_&shy;stream_&shy;socket<span class='anglebracket'>&lt;</span>tcp, Executor<span class='anglebracket'>&gt;;</span></span></ins>
    <span class='keyword'>using</span> acceptor <span class='operator'>=</span> basic_socket_acceptor<span class='anglebracket'>&lt;</span>tcp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> iostream <span class='operator'>=</span> basic_socket_iostream<span class='anglebracket'>&lt;</span>tcp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>class</span> no_delay;

    <span class='comment'>// static members:</span>
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> tcp v4<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> tcp v6<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

    tcp<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
  <span class='curlybracket'>}</span>;

  <span class='comment'>// <a href='#comparisons'>[internet.tcp.comparisons]</a>, tcp comparisons:</span>
  <span class='keyword'>constexpr</span> <span class='keyword'>bool</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> tcp<span class='operator'>&amp;</span> a, <span class='keyword'>const</span> tcp<span class='operator'>&amp;</span> b<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>constexpr</span> <span class='keyword'>bool</span> <span class='keyword'>operator</span><span class='operator'>!</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> tcp<span class='operator'>&amp;</span> a, <span class='keyword'>const</span> tcp<span class='operator'>&amp;</span> b<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

<span class='curlybracket'>}</span> <span class='comment'>// namespace ip</span>
<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre></div>
</div>

<p><em>Update the <code>ip::udp</code> synopsis [internet.udp] as follows:</em></p>

<div class='wording'>
<h2 ><a class='secnum' style='min-width:88pt'>21.20</a> Class <span class='texttt'>ip&#x200b;::&#x200b;udp</span> <a class='abbr_ref'>[internet.udp]</a></h2><div class='para' id='1'><div class='marginalizedparent'><a class='marginalized' href='#1'>1</a></div><div class='sourceLinkParent'><a class='sourceLink' href='#'>#</a></div>The class <span class='texttt'>udp</span> encapsulates the types and flags necessary for UDP sockets.<pre class='codeblock'>
<span class='keyword'>namespace</span> std <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> experimental <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> net <span class='curlybracket'>{</span>
<span class='keyword'>inline</span> <span class='keyword'>namespace</span> v1 <span class='curlybracket'>{</span>
<span class='keyword'>namespace</span> ip <span class='curlybracket'>{</span>

  <span class='keyword'>class</span> udp
  <span class='curlybracket'>{</span>
  <span class='keyword'>public</span><span class='operator'>:</span>
    <span class='comment'>// types:</span>
    <span class='keyword'>using</span> endpoint <span class='operator'>=</span> basic_endpoint<span class='anglebracket'>&lt;</span>udp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> resolver <span class='operator'>=</span> basic_resolver<span class='anglebracket'>&lt;</span>udp<span class='anglebracket'>&gt;</span>;
    <span class='keyword'>using</span> socket <span class='operator'>=</span> basic_datagram_socket<span class='anglebracket'>&lt;</span>udp<span class='anglebracket'>&gt;</span>;
    <ins ><span class='tcode_in_codeblock'><span class='keyword'>template</span><span class='anglebracket'>&lt;</span><span class='keyword'>class</span> Executor<span class='anglebracket'>&gt;</span></span></ins>
    <ins ><span class='tcode_in_codeblock'>  <span class='keyword'>using</span> socket_&shy;for <span class='operator'>=</span> basic_&shy;datagram_&shy;socket<span class='anglebracket'>&lt;</span>udp, Executor<span class='anglebracket'>&gt;;</span></span></ins>

    <span class='comment'>// static members:</span>
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> udp v4<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
    <span class='keyword'>static</span> <span class='keyword'>constexpr</span> udp v6<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

    udp<span class='parenthesis'>(</span><span class='parenthesis'>)</span> <span class='operator'>=</span> <span class='keyword'>delete</span>;
  <span class='curlybracket'>}</span>;

  <span class='comment'>// <a href='#comparisons'>[internet.udp.comparisons]</a>, udp comparisons:</span>
  <span class='keyword'>constexpr</span> <span class='keyword'>bool</span> <span class='keyword'>operator</span><span class='operator'>=</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> udp<span class='operator'>&amp;</span> a, <span class='keyword'>const</span> udp<span class='operator'>&amp;</span> b<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;
  <span class='keyword'>constexpr</span> <span class='keyword'>bool</span> <span class='keyword'>operator</span><span class='operator'>!</span><span class='operator'>=</span><span class='parenthesis'>(</span><span class='keyword'>const</span> udp<span class='operator'>&amp;</span> a, <span class='keyword'>const</span> udp<span class='operator'>&amp;</span> b<span class='parenthesis'>)</span> <span class='keyword'>noexcept</span>;

<span class='curlybracket'>}</span> <span class='comment'>// namespace ip</span>
<span class='curlybracket'>}</span> <span class='comment'>// inline namespace v1</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace net</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace experimental</span>
<span class='curlybracket'>}</span> <span class='comment'>// namespace std</span>
</pre></div>
</div>

</div>

<h2>7. History</h2>

<div class="changed">
<p>Changes in R3:</p>
<em>Note: changed sections in R3 are indicated by a pale blue background with a dark blue line on the right margin.</em>
<ul>
<li>Added <code>socket_for</code> to AcceptableProtocol requirements, class <code>ip::tcp</code>, and class <code>ip::udp</code>.</li>
<li>Renamed template type alias <code>basic_socket_acceptor::rebind_socket_executor</code> to <code>socket_type_for</code>.</li>
</ul>
</div>

<p>Changes in R2:</p>
<ul>
<li>Changed <code>rebind_executor</code> to be a template type alias.</li>
<li>Reinstated <code>basic_socket_acceptor::socket_type</code>.</li>
<li>Added template type alias <code>basic_socket_acceptor::rebind_socket_executor</code>.</li>
<li>Changed <code>basic_socket_acceptor::accept</code> and <code>basic_socket_acceptor::async_accept</code> overloads that take an executor (or execution context) to use the new <code>rebind_socket_executor</code> type alias.</li>
</ul>

<p>Changes in R1:</p>
<ul>
<li>Added detailed wording.</li>
<li>Added discussion of specialization of I/O object types.</li>
<li>Updated implementation experience.</li>
</ul>

</body>
</html>
