<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="An HTTP/3 connection."><title>Connection in quiche::h3 - Rust</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-46f98efaafac5295.ttf.woff2,FiraSans-Regular-018c141bf0843ffd.woff2,FiraSans-Medium-8f9a781e4970d388.woff2,SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2,SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../../static.files/rustdoc-dd39b87e5fcfba68.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="quiche" data-themes="" data-resource-suffix="" data-rustdoc-version="1.80.0-nightly (d84b90375 2024-05-19)" data-channel="nightly" data-search-js="search-d52510db62a78183.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../../static.files/storage-118b08c4c78b968e.js"></script><script defer src="sidebar-items.js"></script><script defer src="../../static.files/main-20a3ad099b048cf2.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-df360f571f6edeae.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle" title="show sidebar"></button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../quiche/index.html">quiche</a><span class="version">0.21.0</span></h2></div><h2 class="location"><a href="#">Connection</a></h2><div class="sidebar-elems"><section><h3><a href="#implementations">Methods</a></h3><ul class="block method"><li><a href="#method.dgram_enabled_by_peer">dgram_enabled_by_peer</a></li><li><a href="#method.extended_connect_enabled_by_peer">extended_connect_enabled_by_peer</a></li><li><a href="#method.peer_settings_raw">peer_settings_raw</a></li><li><a href="#method.poll">poll</a></li><li><a href="#method.recv_body">recv_body</a></li><li><a href="#method.send_body">send_body</a></li><li><a href="#method.send_goaway">send_goaway</a></li><li><a href="#method.send_priority_update_for_request">send_priority_update_for_request</a></li><li><a href="#method.send_request">send_request</a></li><li><a href="#method.send_response">send_response</a></li><li><a href="#method.send_response_with_priority">send_response_with_priority</a></li><li><a href="#method.take_last_priority_update">take_last_priority_update</a></li><li><a href="#method.with_transport">with_transport</a></li></ul><h3><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><ul class="block synthetic-implementation"><li><a href="#impl-Freeze-for-Connection">Freeze</a></li><li><a href="#impl-RefUnwindSafe-for-Connection">RefUnwindSafe</a></li><li><a href="#impl-Send-for-Connection">Send</a></li><li><a href="#impl-Sync-for-Connection">Sync</a></li><li><a href="#impl-Unpin-for-Connection">Unpin</a></li><li><a href="#impl-UnwindSafe-for-Connection">UnwindSafe</a></li></ul><h3><a href="#blanket-implementations">Blanket Implementations</a></h3><ul class="block blanket-implementation"><li><a href="#impl-Any-for-T">Any</a></li><li><a href="#impl-Borrow%3CT%3E-for-T">Borrow&lt;T&gt;</a></li><li><a href="#impl-BorrowMut%3CT%3E-for-T">BorrowMut&lt;T&gt;</a></li><li><a href="#impl-From%3CT%3E-for-T">From&lt;T&gt;</a></li><li><a href="#impl-Into%3CU%3E-for-T">Into&lt;U&gt;</a></li><li><a href="#impl-IntoEither-for-T">IntoEither</a></li><li><a href="#impl-TryFrom%3CU%3E-for-T">TryFrom&lt;U&gt;</a></li><li><a href="#impl-TryInto%3CU%3E-for-T">TryInto&lt;U&gt;</a></li></ul></section><h2><a href="index.html">In quiche::h3</a></h2></div></nav><div class="sidebar-resizer"></div><main><div class="width-limiter"><rustdoc-search></rustdoc-search><section id="main-content" class="content"><div class="main-heading"><h1>Struct <a href="../index.html">quiche</a>::<wbr><a href="index.html">h3</a>::<wbr><a class="struct" href="#">Connection</a><button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1><span class="out-of-band"><a class="src" href="../../src/quiche/h3/mod.rs.html#919-947">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>&#x2212;</span>]</button></span></div><pre class="rust item-decl"><code>pub struct Connection { <span class="comment">/* private fields */</span> }</code></pre><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>An HTTP/3 connection.</p>
</div></details><h2 id="implementations" class="section-header">Implementations<a href="#implementations" class="anchor">§</a></h2><div id="implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Connection" class="impl"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#949-2836">source</a><a href="#impl-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.with_transport" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1028-1061">source</a><h4 class="code-header">pub fn <a href="#method.with_transport" class="fn">with_transport</a>(
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    config: &amp;<a class="struct" href="struct.Config.html" title="struct quiche::h3::Config">Config</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a>&gt;</h4></section></summary><div class="docblock"><p>Creates a new HTTP/3 connection using the provided QUIC connection.</p>
<p>This will also initiate the HTTP/3 handshake with the peer by opening
all control streams (including QPACK) and sending the local settings.</p>
<p>On success the new connection is returned.</p>
<p>The <a href="../enum.Error.html#variant.StreamLimit"><code>StreamLimit</code></a> error is returned when the HTTP/3 control stream
cannot be created due to stream limits.</p>
<p>The <a href="../enum.Error.html#variant.InternalError"><code>InternalError</code></a> error is returned when either the underlying QUIC
connection is not in a suitable state, or the HTTP/3 control stream
cannot be created due to flow control limits.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_request" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1079-1117">source</a><h4 class="code-header">pub fn <a href="#method.send_request" class="fn">send_request</a>&lt;T: <a class="trait" href="trait.NameValue.html" title="trait quiche::h3::NameValue">NameValue</a>&gt;(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    headers: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[T]</a>,
    fin: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>&gt;</h4></section></summary><div class="docblock"><p>Sends an HTTP/3 request.</p>
<p>The request is encoded from the provided list of headers without a
body, and sent on a newly allocated stream. To include a body,
set <code>fin</code> as <code>false</code> and subsequently call <a href="struct.Connection.html#method.send_body"><code>send_body()</code></a> with the
same <code>conn</code> and the <code>stream_id</code> returned from this method.</p>
<p>On success the newly allocated stream ID is returned.</p>
<p>The <a href="enum.Error.html#variant.StreamBlocked"><code>StreamBlocked</code></a> error is returned when the underlying QUIC stream
doesn’t have enough capacity for the operation to complete. When this
happens the application should retry the operation once the stream is
reported as writable again.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_response" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1132-1143">source</a><h4 class="code-header">pub fn <a href="#method.send_response" class="fn">send_response</a>&lt;T: <a class="trait" href="trait.NameValue.html" title="trait quiche::h3::NameValue">NameValue</a>&gt;(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    stream_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>,
    headers: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[T]</a>,
    fin: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>&gt;</h4></section></summary><div class="docblock"><p>Sends an HTTP/3 response on the specified stream with default priority.</p>
<p>This method sends the provided <code>headers</code> without a body. To include a
body, set <code>fin</code> as <code>false</code> and subsequently call <a href="struct.Connection.html#method.send_body"><code>send_body()</code></a> with
the same <code>conn</code> and <code>stream_id</code>.</p>
<p>The <a href="enum.Error.html#variant.StreamBlocked"><code>StreamBlocked</code></a> error is returned when the underlying QUIC stream
doesn’t have enough capacity for the operation to complete. When this
happens the application should retry the operation once the stream is
reported as writable again.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_response_with_priority" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1159-1178">source</a><h4 class="code-header">pub fn <a href="#method.send_response_with_priority" class="fn">send_response_with_priority</a>&lt;T: <a class="trait" href="trait.NameValue.html" title="trait quiche::h3::NameValue">NameValue</a>&gt;(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    stream_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>,
    headers: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">[T]</a>,
    priority: &amp;<a class="struct" href="struct.Priority.html" title="struct quiche::h3::Priority">Priority</a>,
    fin: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>&gt;</h4></section></summary><div class="docblock"><p>Sends an HTTP/3 response on the specified stream with specified
priority.</p>
<p>The <code>priority</code> parameter represents <a href="https://www.rfc-editor.org/rfc/rfc9218.html#section-4.">Extensible Priority</a>
parameters. If the urgency is outside the range 0-7, it will be clamped
to 7.</p>
<p>The <a href="enum.Error.html#variant.StreamBlocked"><code>StreamBlocked</code></a> error is returned when the underlying QUIC stream
doesn’t have enough capacity for the operation to complete. When this
happens the application should retry the operation once the stream is
reported as writable again.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_body" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1294-1400">source</a><h4 class="code-header">pub fn <a href="#method.send_body" class="fn">send_body</a>(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    stream_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>,
    body: &amp;[<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>],
    fin: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt;</h4></section></summary><div class="docblock"><p>Sends an HTTP/3 body chunk on the given stream.</p>
<p>On success the number of bytes written is returned, or <a href="enum.Error.html#variant.Done"><code>Done</code></a> if no
bytes could be written (e.g. because the stream is blocked).</p>
<p>Note that the number of written bytes returned can be lower than the
length of the input buffer when the underlying QUIC stream doesn’t have
enough capacity for the operation to complete.</p>
<p>When a partial write happens (including when <a href="enum.Error.html#variant.Done"><code>Done</code></a> is returned) the
application should retry the operation once the stream is reported as
writable again.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.dgram_enabled_by_peer" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1409-1412">source</a><h4 class="code-header">pub fn <a href="#method.dgram_enabled_by_peer" class="fn">dgram_enabled_by_peer</a>(&amp;self, conn: &amp;<a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the peer enabled HTTP/3 DATAGRAM frame support.</p>
<p>Support is signalled by the peer’s SETTINGS, so this method always
returns false until they have been processed using the <a href="struct.Connection.html#method.poll"><code>poll()</code></a>
method.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.extended_connect_enabled_by_peer" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1421-1423">source</a><h4 class="code-header">pub fn <a href="#method.extended_connect_enabled_by_peer" class="fn">extended_connect_enabled_by_peer</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns whether the peer enabled extended CONNECT support.</p>
<p>Support is signalled by the peer’s SETTINGS, so this method always
returns false until they have been processed using the <a href="struct.Connection.html#method.poll"><code>poll()</code></a>
method.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.recv_body" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1436-1494">source</a><h4 class="code-header">pub fn <a href="#method.recv_body" class="fn">recv_body</a>(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    stream_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>,
    out: &amp;mut [<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>]
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt;</h4></section></summary><div class="docblock"><p>Reads request or response body data into the provided buffer.</p>
<p>Applications should call this method whenever the <a href="struct.Connection.html#method.poll"><code>poll()</code></a> method
returns a <a href="enum.Event.html#variant.Data"><code>Data</code></a> event.</p>
<p>On success the amount of bytes read is returned, or <a href="enum.Error.html#variant.Done"><code>Done</code></a> if there
is no data to read.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_priority_update_for_request" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1510-1596">source</a><h4 class="code-header">pub fn <a href="#method.send_priority_update_for_request" class="fn">send_priority_update_for_request</a>(
    &amp;mut self,
    conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>,
    stream_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>,
    priority: &amp;<a class="struct" href="struct.Priority.html" title="struct quiche::h3::Priority">Priority</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>&gt;</h4></section></summary><div class="docblock"><p>Sends a PRIORITY_UPDATE frame on the control stream with specified
request stream ID and priority.</p>
<p>The <code>priority</code> parameter represents <a href="https://www.rfc-editor.org/rfc/rfc9218.html#section-4.">Extensible Priority</a>
parameters. If the urgency is outside the range 0-7, it will be clamped
to 7.</p>
<p>The <a href="enum.Error.html#variant.StreamBlocked"><code>StreamBlocked</code></a> error is returned when the underlying QUIC stream
doesn’t have enough capacity for the operation to complete. When this
happens the application should retry the operation once the stream is
reported as writable again.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.take_last_priority_update" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1612-1620">source</a><h4 class="code-header">pub fn <a href="#method.take_last_priority_update" class="fn">take_last_priority_update</a>(
    &amp;mut self,
    prioritized_element_id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>
) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>&gt;&gt;</h4></section></summary><div class="docblock"><p>Take the last PRIORITY_UPDATE for a prioritized element ID.</p>
<p>When the <a href="struct.Connection.html#method.poll"><code>poll()</code></a> method returns a <a href="enum.Event.html#variant.PriorityUpdate"><code>PriorityUpdate</code></a> event for a
prioritized element, the event has triggered and will not rearm until
applications call this method. It is recommended that applications defer
taking the PRIORITY_UPDATE until after <a href="struct.Connection.html#method.poll"><code>poll()</code></a> returns <a href="enum.Error.html#variant.Done"><code>Done</code></a>.</p>
<p>On success the Priority Field Value is returned, or <a href="enum.Error.html#variant.Done"><code>Done</code></a> if there is
no PRIORITY_UPDATE to read (either because there is no value to take, or
because the prioritized element does not exist).</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.poll" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1659-1738">source</a><h4 class="code-header">pub fn <a href="#method.poll" class="fn">poll</a>(&amp;mut self, conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, <a class="enum" href="enum.Event.html" title="enum quiche::h3::Event">Event</a>)&gt;</h4></section></summary><div class="docblock"><p>Processes HTTP/3 data received from the peer.</p>
<p>On success it returns an <a href="enum.Event.html"><code>Event</code></a> and an ID, or <a href="enum.Error.html#variant.Done"><code>Done</code></a> when there are
no events to report.</p>
<p>Note that all events are edge-triggered, meaning that once reported they
will not be reported again by calling this method again, until the event
is re-armed.</p>
<p>The events <a href="enum.Event.html#variant.Headers"><code>Headers</code></a>, <a href="enum.Event.html#variant.Data"><code>Data</code></a> and <a href="enum.Event.html#variant.Finished"><code>Finished</code></a> return a stream ID,
which is used in methods <a href="struct.Connection.html#method.recv_body"><code>recv_body()</code></a>, <a href="struct.Connection.html#method.send_response"><code>send_response()</code></a> or
<a href="struct.Connection.html#method.send_body"><code>send_body()</code></a>.</p>
<p>The event <a href="enum.Event.html#variant.GoAWay"><code>GoAway</code></a> returns an ID that depends on the connection role.
A client receives the largest processed stream ID. A server receives the
the largest permitted push ID.</p>
<p>The event <a href="enum.Event.html#variant.PriorityUpdate"><code>PriorityUpdate</code></a> only occurs at servers. It returns a
prioritized element ID that is used in the method
<a href="struct.Connection.html#method.take_last_priority_update"><code>take_last_priority_update()</code></a>, which rearms the event for that ID.</p>
<p>If an error occurs while processing data, the connection is closed with
the appropriate error code, using the transport’s <a href="../struct.Connection.html#method.close"><code>close()</code></a> method.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.send_goaway" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1751-1806">source</a><h4 class="code-header">pub fn <a href="#method.send_goaway" class="fn">send_goaway</a>(&amp;mut self, conn: &amp;mut <a class="struct" href="../struct.Connection.html" title="struct quiche::Connection">Connection</a>, id: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>) -&gt; <a class="type" href="type.Result.html" title="type quiche::h3::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>&gt;</h4></section></summary><div class="docblock"><p>Sends a GOAWAY frame to initiate graceful connection closure.</p>
<p>When quiche is used in the server role, the <code>id</code> parameter is the stream
ID of the highest processed request. This can be any valid ID between 0
and 2^62-4. However, the ID cannot be increased. Failure to satisfy
these conditions will return an error.</p>
<p>This method does not close the QUIC connection. Applications are
required to call <a href="../struct.Connection.html#method.close"><code>close()</code></a> themselves.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.peer_settings_raw" class="method"><a class="src rightside" href="../../src/quiche/h3/mod.rs.html#1811-1813">source</a><h4 class="code-header">pub fn <a href="#method.peer_settings_raw" class="fn">peer_settings_raw</a>(&amp;self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;&amp;[(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u64.html">u64</a>)]&gt;</h4></section></summary><div class="docblock"><p>Gets the raw settings from peer including unknown and reserved types.</p>
<p>The order of settings is the same as received in the SETTINGS frame.</p>
</div></details></div></details></div><h2 id="synthetic-implementations" class="section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor">§</a></h2><div id="synthetic-implementations-list"><section id="impl-Freeze-for-Connection" class="impl"><a href="#impl-Freeze-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Freeze.html" title="trait core::marker::Freeze">Freeze</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section><section id="impl-RefUnwindSafe-for-Connection" class="impl"><a href="#impl-RefUnwindSafe-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section><section id="impl-Send-for-Connection" class="impl"><a href="#impl-Send-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section><section id="impl-Sync-for-Connection" class="impl"><a href="#impl-Sync-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section><section id="impl-Unpin-for-Connection" class="impl"><a href="#impl-Unpin-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section><section id="impl-UnwindSafe-for-Connection" class="impl"><a href="#impl-UnwindSafe-for-Connection" class="anchor">§</a><h3 class="code-header">impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.Connection.html" title="struct quiche::h3::Connection">Connection</a></h3></section></div><h2 id="blanket-implementations" class="section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor">§</a></h2><div id="blanket-implementations-list"><details class="toggle implementors-toggle"><summary><section id="impl-Any-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/any.rs.html#140">source</a><a href="#impl-Any-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T<div class="where">where
    T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.type_id" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/any.rs.html#141">source</a><a href="#method.type_id" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id" class="fn">type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></section></summary><div class='docblock'>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Borrow%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#208">source</a><a href="#impl-Borrow%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T<div class="where">where
    T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#210">source</a><a href="#method.borrow" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow" class="fn">borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-BorrowMut%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#216">source</a><a href="#impl-BorrowMut%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T<div class="where">where
    T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow_mut" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#217">source</a><a href="#method.borrow_mut" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fn">borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut T</a></h4></section></summary><div class='docblock'>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-From%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#765">source</a><a href="#impl-From%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#768">source</a><a href="#method.from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from" class="fn">from</a>(t: T) -&gt; T</h4></section></summary><div class="docblock"><p>Returns the argument unchanged.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Into%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#748-750">source</a><a href="#impl-Into%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T<div class="where">where
    U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#758">source</a><a href="#method.into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into" class="fn">into</a>(self) -&gt; U</h4></section></summary><div class="docblock"><p>Calls <code>U::from(self)</code>.</p>
<p>That is, this conversion is whatever the implementation of
<code><a href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for U</code> chooses to do.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-IntoEither-for-T" class="impl"><a class="src rightside" href="https://docs.rs/either/1/src/either/into_either.rs.html#64">source</a><a href="#impl-IntoEither-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://docs.rs/either/1/either/into_either/trait.IntoEither.html" title="trait either::into_either::IntoEither">IntoEither</a> for T</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into_either" class="method trait-impl"><a class="src rightside" href="https://docs.rs/either/1/src/either/into_either.rs.html#29">source</a><a href="#method.into_either" class="anchor">§</a><h4 class="code-header">fn <a href="https://docs.rs/either/1/either/into_either/trait.IntoEither.html#method.into_either" class="fn">into_either</a>(self, into_left: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -&gt; <a class="enum" href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either">Either</a>&lt;Self, Self&gt;</h4></section></summary><div class='docblock'>Converts <code>self</code> into a <a href="https://docs.rs/either/1/either/enum.Either.html#variant.Left" title="variant either::Either::Left"><code>Left</code></a> variant of <a href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either"><code>Either&lt;Self, Self&gt;</code></a>
if <code>into_left</code> is <code>true</code>.
Converts <code>self</code> into a <a href="https://docs.rs/either/1/either/enum.Either.html#variant.Right" title="variant either::Either::Right"><code>Right</code></a> variant of <a href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either"><code>Either&lt;Self, Self&gt;</code></a>
otherwise. <a href="https://docs.rs/either/1/either/into_either/trait.IntoEither.html#method.into_either">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.into_either_with" class="method trait-impl"><a class="src rightside" href="https://docs.rs/either/1/src/either/into_either.rs.html#55-57">source</a><a href="#method.into_either_with" class="anchor">§</a><h4 class="code-header">fn <a href="https://docs.rs/either/1/either/into_either/trait.IntoEither.html#method.into_either_with" class="fn">into_either_with</a>&lt;F&gt;(self, into_left: F) -&gt; <a class="enum" href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either">Either</a>&lt;Self, Self&gt;<div class="where">where
    F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;Self</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,</div></h4></section></summary><div class='docblock'>Converts <code>self</code> into a <a href="https://docs.rs/either/1/either/enum.Either.html#variant.Left" title="variant either::Either::Left"><code>Left</code></a> variant of <a href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either"><code>Either&lt;Self, Self&gt;</code></a>
if <code>into_left(&amp;self)</code> returns <code>true</code>.
Converts <code>self</code> into a <a href="https://docs.rs/either/1/either/enum.Either.html#variant.Right" title="variant either::Either::Right"><code>Right</code></a> variant of <a href="https://docs.rs/either/1/either/enum.Either.html" title="enum either::Either"><code>Either&lt;Self, Self&gt;</code></a>
otherwise. <a href="https://docs.rs/either/1/either/into_either/trait.IntoEither.html#method.into_either_with">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryFrom%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#805-807">source</a><a href="#impl-TryFrom%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T<div class="where">where
    U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error-1" class="associatedtype trait-impl"><a href="#associatedtype.Error-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#812">source</a><a href="#method.try_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from" class="fn">try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryInto%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#790-792">source</a><a href="#impl-TryInto%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T<div class="where">where
    U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error" class="associatedtype trait-impl"><a href="#associatedtype.Error" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#797">source</a><a href="#method.try_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into" class="fn">try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details></div></section></div></main></body></html>