evan/ludum-dare-50
Archived
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2022-04-04. You can view files and clone it, but cannot push or open issues or pull requests.
ludum-dare-50/rustdoc/tokio/net/struct.UnixStream.html

515 lines
103 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!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="A structure representing a connected Unix socket."><meta name="keywords" content="rust, rustlang, rust-lang, UnixStream"><title>UnixStream in tokio::net - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../../SourceSerif4-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../FiraSans-Regular.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../FiraSans-Medium.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../SourceCodePro-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../SourceSerif4-Bold.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../../SourceCodePro-Semibold.ttf.woff2"><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../ayu.css" disabled><link rel="stylesheet" type="text/css" href="../../dark.css" disabled><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script id="default-settings" ></script><script src="../../storage.js"></script><script src="../../crates.js"></script><script defer src="../../main.js"></script>
<noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="alternate icon" type="image/png" href="../../favicon-16x16.png"><link rel="alternate icon" type="image/png" href="../../favicon-32x32.png"><link rel="icon" type="image/svg+xml" href="../../favicon.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="sidebar"><div class="sidebar-menu" role="button">&#9776;</div><a class="sidebar-logo" href="../../tokio/index.html"><div class="logo-container"><img class="rust-logo" src="../../rust-logo.png" alt="logo"></div>
</a><h2 class="location">Struct UnixStream</h2><div class="sidebar-elems"><div class="block items"><h3 class="sidebar-title"><a href="#implementations">Methods</a></h3><div class="sidebar-links"><a href="#method.connect">connect</a><a href="#method.from_std">from_std</a><a href="#method.into_split">into_split</a><a href="#method.into_std">into_std</a><a href="#method.local_addr">local_addr</a><a href="#method.pair">pair</a><a href="#method.peer_addr">peer_addr</a><a href="#method.peer_cred">peer_cred</a><a href="#method.poll_read_ready">poll_read_ready</a><a href="#method.poll_write_ready">poll_write_ready</a><a href="#method.readable">readable</a><a href="#method.ready">ready</a><a href="#method.split">split</a><a href="#method.take_error">take_error</a><a href="#method.try_io">try_io</a><a href="#method.try_read">try_read</a><a href="#method.try_read_vectored">try_read_vectored</a><a href="#method.try_write">try_write</a><a href="#method.try_write_vectored">try_write_vectored</a><a href="#method.writable">writable</a></div><h3 class="sidebar-title"><a href="#trait-implementations">Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-AsRawFd">AsRawFd</a><a href="#impl-AsRef%3CUnixStream%3E">AsRef&lt;UnixStream&gt;</a><a href="#impl-AsyncRead">AsyncRead</a><a href="#impl-AsyncWrite">AsyncWrite</a><a href="#impl-Debug">Debug</a><a href="#impl-TryFrom%3CUnixStream%3E">TryFrom&lt;UnixStream&gt;</a></div><h3 class="sidebar-title"><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-RefUnwindSafe">RefUnwindSafe</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a><a href="#impl-Unpin">Unpin</a><a href="#impl-UnwindSafe">UnwindSafe</a></div><h3 class="sidebar-title"><a href="#blanket-implementations">Blanket Implementations</a></h3><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow%3CT%3E">Borrow&lt;T&gt;</a><a href="#impl-BorrowMut%3CT%3E">BorrowMut&lt;T&gt;</a><a href="#impl-From%3CT%3E">From&lt;T&gt;</a><a href="#impl-Into%3CU%3E">Into&lt;U&gt;</a><a href="#impl-TryFrom%3CU%3E">TryFrom&lt;U&gt;</a><a href="#impl-TryInto%3CU%3E">TryInto&lt;U&gt;</a></div></div><h2 class="location">Other items in<br><a href="../index.html">tokio</a>::<wbr><a href="index.html">net</a></h2><div id="sidebar-vars" data-name="UnixStream" data-ty="struct" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></nav><main><div class="width-limiter"><div class="sub-container"><a class="sub-logo-container" href="../../tokio/index.html"><img class="rust-logo" src="../../rust-logo.png" alt="logo"></a><nav class="sub"><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu" title="themes"><img width="18" height="18" alt="Pick another theme!" src="../../brush.svg"></button><div id="theme-choices" role="menu"></div></div><form class="search-form"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><button type="button" id="help-button" title="help">?</button><a id="settings-menu" href="../../settings.html" title="settings"><img width="18" height="18" alt="Change settings" src="../../wheel.svg"></a></div></form></nav></div><section id="main-content" class="content"><h1 class="fqn"><span class="in-band">Struct <a href="../index.html">tokio</a>::<wbr><a href="index.html">net</a>::<wbr><a class="struct" href="#">UnixStream</a><button id="copy-path" onclick="copy_path(this)" title="Copy item path to clipboard"><img src="../../clipboard.svg" width="19" height="18" alt="Copy item path"></button></span><span class="out-of-band"><span id="render-detail"><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">&#x2212;</span>]</a></span><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#35-37" title="goto source code">[src]</a></span></h1><div class="docblock item-decl"><pre class="rust struct"><code>pub struct UnixStream { /* fields omitted */ }</code></pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>A structure representing a connected Unix socket.</p>
<p>This socket can be connected directly with <code>UnixStream::connect</code> or accepted
from a listener with <code>UnixListener::incoming</code>. Additionally, a pair of
anonymous Unix sockets can be created with <code>UnixStream::pair</code>.</p>
<p>To shut down the stream in the write direction, you can call the
<a href="fn@crate::io::AsyncWriteExt::shutdown"><code>shutdown()</code></a> method. This will cause the other peer to receive a read of
length 0, indicating that no more data will be sent. This only closes
the stream in one direction.</p>
</div></details><h2 id="implementations" class="small-section-header">Implementations<a href="#implementations" class="anchor"></a></h2><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#40-862" title="goto source code">[src]</a></div><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.connect" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#46-60" title="goto source code">[src]</a></div><a href="#method.connect" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.connect" class="fnname">connect</a>&lt;P&gt;(path: P) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;P: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="struct" href="https://doc.rust-lang.org/1.59.0/std/path/struct.Path.html" title="struct std::path::Path">Path</a>&gt;,&nbsp;</span></h4></div></summary><div class="docblock"><p>Connects to the socket named by <code>path</code>.</p>
<p>This function will create a new Unix socket and connect to the path
specified, associating the returned stream with the default event loop’s
handle.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ready" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#131-134" title="goto source code">[src]</a></div><a href="#method.ready" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.ready" class="fnname">ready</a>(&amp;self, interest: <a class="struct" href="../io/struct.Interest.html" title="struct tokio::io::Interest">Interest</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="../io/struct.Ready.html" title="struct tokio::io::Ready">Ready</a>&gt;</h4></div></summary><div class="docblock"><p>Waits for any of the requested ready states.</p>
<p>This function is usually paired with <code>try_read()</code> or <code>try_write()</code>. It
can be used to concurrently read / write to the same socket on a single
task without splitting the socket.</p>
<h5 id="cancel-safety" class="section-header"><a href="#cancel-safety">Cancel safety</a></h5>
<p>This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to read or write that fails with <code>WouldBlock</code> or
<code>Poll::Pending</code>.</p>
<h5 id="examples" class="section-header"><a href="#examples">Examples</a></h5>
<p>Concurrently read and write to the stream on the same task without
splitting.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::io::Interest</span>;
<span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">loop</span> {
<span class="kw">let</span> <span class="ident">ready</span> <span class="op">=</span> <span class="ident">stream</span>.<span class="ident">ready</span>(<span class="ident">Interest::READABLE</span> <span class="op">|</span> <span class="ident">Interest::WRITABLE</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_readable</span>() {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">data</span> <span class="op">=</span> <span class="macro">vec!</span>[<span class="number">0</span>; <span class="number">1024</span>];
<span class="comment">// Try to read data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_read</span>(<span class="kw-2">&amp;mut</span> <span class="ident">data</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="macro">println!</span>(<span class="string">&quot;read {} bytes&quot;</span>, <span class="ident">n</span>);
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="kw">if</span> <span class="ident">ready</span>.<span class="ident">is_writable</span>() {
<span class="comment">// Try to write data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_write</span>(<span class="string">b&quot;hello world&quot;</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="macro">println!</span>(<span class="string">&quot;write {} bytes&quot;</span>, <span class="ident">n</span>);
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.readable" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#188-191" title="goto source code">[src]</a></div><a href="#method.readable" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.readable" class="fnname">readable</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;</h4></div></summary><div class="docblock"><p>Waits for the socket to become readable.</p>
<p>This function is equivalent to <code>ready(Interest::READABLE)</code> and is usually
paired with <code>try_read()</code>.</p>
<h5 id="cancel-safety-1" class="section-header"><a href="#cancel-safety-1">Cancel safety</a></h5>
<p>This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to read that fails with <code>WouldBlock</code> or
<code>Poll::Pending</code>.</p>
<h5 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">msg</span> <span class="op">=</span> <span class="macro">vec!</span>[<span class="number">0</span>; <span class="number">1024</span>];
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be readable</span>
<span class="ident">stream</span>.<span class="ident">readable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Try to read data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_read</span>(<span class="kw-2">&amp;mut</span> <span class="ident">msg</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="ident">msg</span>.<span class="ident">truncate</span>(<span class="ident">n</span>);
<span class="kw">break</span>;
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="macro">println!</span>(<span class="string">&quot;GOT = {:?}&quot;</span>, <span class="ident">msg</span>);
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_read_ready" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#222-224" title="goto source code">[src]</a></div><a href="#method.poll_read_ready" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.poll_read_ready" class="fnname">poll_read_ready</a>(&amp;self, cx: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Polls for read readiness.</p>
<p>If the unix stream is not currently ready for reading, this method will
store a clone of the <code>Waker</code> from the provided <code>Context</code>. When the unix
stream becomes ready for reading, <code>Waker::wake</code> will be called on the
waker.</p>
<p>Note that on multiple calls to <code>poll_read_ready</code> or <code>poll_read</code>, only
the <code>Waker</code> from the <code>Context</code> passed to the most recent call is
scheduled to receive a wakeup. (However, <code>poll_write_ready</code> retains a
second, independent waker.)</p>
<p>This function is intended for cases where creating and pinning a future
via <a href="struct.UnixStream.html#method.readable"><code>readable</code></a> is not feasible. Where possible, using <a href="struct.UnixStream.html#method.readable"><code>readable</code></a> is
preferred, as this supports polling from multiple tasks at once.</p>
<h5 id="return-value" class="section-header"><a href="#return-value">Return value</a></h5>
<p>The function returns:</p>
<ul>
<li><code>Poll::Pending</code> if the unix stream is not ready for reading.</li>
<li><code>Poll::Ready(Ok(()))</code> if the unix stream is ready for reading.</li>
<li><code>Poll::Ready(Err(e))</code> if an error is encountered.</li>
</ul>
<h5 id="errors" class="section-header"><a href="#errors">Errors</a></h5>
<p>This function may encounter any standard I/O error except <code>WouldBlock</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_read" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#287-291" title="goto source code">[src]</a></div><a href="#method.try_read" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_read" class="fnname">try_read</a>(&amp;self, buf: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;mut [</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;</h4></div></summary><div class="docblock"><p>Try to read data from the stream into the provided buffer, returning how
many bytes were read.</p>
<p>Receives any pending data from the socket but does not wait for new data
to arrive. On success, returns the number of bytes read. Because
<code>try_read()</code> is non-blocking, the buffer does not have to be stored by
the async task and can exist entirely on the stack.</p>
<p>Usually, <a href="struct.UnixStream.html#method.readable"><code>readable()</code></a> or <a href="struct.UnixStream.html#method.ready"><code>ready()</code></a> is used with this function.</p>
<h5 id="return" class="section-header"><a href="#return">Return</a></h5>
<p>If data is successfully read, <code>Ok(n)</code> is returned, where <code>n</code> is the
number of bytes read. <code>Ok(0)</code> indicates the stream’s read half is closed
and will no longer yield data. If the stream is not ready to read data
<code>Err(io::ErrorKind::WouldBlock)</code> is returned.</p>
<h5 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be readable</span>
<span class="ident">stream</span>.<span class="ident">readable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Creating the buffer **after** the `await` prevents it from</span>
<span class="comment">// being stored in the async task.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">4096</span>];
<span class="comment">// Try to read data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_read</span>(<span class="kw-2">&amp;mut</span> <span class="ident">buf</span>) {
<span class="prelude-val">Ok</span>(<span class="number">0</span>) =&gt; <span class="kw">break</span>,
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="macro">println!</span>(<span class="string">&quot;read {} bytes&quot;</span>, <span class="ident">n</span>);
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_read_vectored" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#365-369" title="goto source code">[src]</a></div><a href="#method.try_read_vectored" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_read_vectored" class="fnname">try_read_vectored</a>(&amp;self, bufs: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;mut [</a><a class="struct" href="https://doc.rust-lang.org/1.59.0/std/io/struct.IoSliceMut.html" title="struct std::io::IoSliceMut">IoSliceMut</a>&lt;'_&gt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;</h4></div></summary><div class="docblock"><p>Tries to read data from the stream into the provided buffers, returning
how many bytes were read.</p>
<p>Data is copied to fill each buffer in order, with the final buffer
written to possibly being only partially filled. This method behaves
equivalently to a single call to <a href="struct.UnixStream.html#method.try_read"><code>try_read()</code></a> with concatenated
buffers.</p>
<p>Receives any pending data from the socket but does not wait for new data
to arrive. On success, returns the number of bytes read. Because
<code>try_read_vectored()</code> is non-blocking, the buffer does not have to be
stored by the async task and can exist entirely on the stack.</p>
<p>Usually, <a href="struct.UnixStream.html#method.readable"><code>readable()</code></a> or <a href="struct.UnixStream.html#method.ready"><code>ready()</code></a> is used with this function.</p>
<h5 id="return-1" class="section-header"><a href="#return-1">Return</a></h5>
<p>If data is successfully read, <code>Ok(n)</code> is returned, where <code>n</code> is the
number of bytes read. <code>Ok(0)</code> indicates the stream’s read half is closed
and will no longer yield data. If the stream is not ready to read data
<code>Err(io::ErrorKind::WouldBlock)</code> is returned.</p>
<h5 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>::{<span class="self">self</span>, <span class="ident">IoSliceMut</span>};
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be readable</span>
<span class="ident">stream</span>.<span class="ident">readable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Creating the buffer **after** the `await` prevents it from</span>
<span class="comment">// being stored in the async task.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf_a</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">512</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf_b</span> <span class="op">=</span> [<span class="number">0</span>; <span class="number">1024</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bufs</span> <span class="op">=</span> [
<span class="ident">IoSliceMut::new</span>(<span class="kw-2">&amp;mut</span> <span class="ident">buf_a</span>),
<span class="ident">IoSliceMut::new</span>(<span class="kw-2">&amp;mut</span> <span class="ident">buf_b</span>),
];
<span class="comment">// Try to read data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_read_vectored</span>(<span class="kw-2">&amp;mut</span> <span class="ident">bufs</span>) {
<span class="prelude-val">Ok</span>(<span class="number">0</span>) =&gt; <span class="kw">break</span>,
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="macro">println!</span>(<span class="string">&quot;read {} bytes&quot;</span>, <span class="ident">n</span>);
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.writable" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#500-503" title="goto source code">[src]</a></div><a href="#method.writable" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.writable" class="fnname">writable</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;</h4></div></summary><div class="docblock"><p>Waits for the socket to become writable.</p>
<p>This function is equivalent to <code>ready(Interest::WRITABLE)</code> and is usually
paired with <code>try_write()</code>.</p>
<h5 id="cancel-safety-2" class="section-header"><a href="#cancel-safety-2">Cancel safety</a></h5>
<p>This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to write that fails with <code>WouldBlock</code> or
<code>Poll::Pending</code>.</p>
<h5 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be writable</span>
<span class="ident">stream</span>.<span class="ident">writable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Try to write data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_write</span>(<span class="string">b&quot;hello world&quot;</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="kw">break</span>;
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_write_ready" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#534-536" title="goto source code">[src]</a></div><a href="#method.poll_write_ready" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.poll_write_ready" class="fnname">poll_write_ready</a>(&amp;self, cx: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Polls for write readiness.</p>
<p>If the unix stream is not currently ready for writing, this method will
store a clone of the <code>Waker</code> from the provided <code>Context</code>. When the unix
stream becomes ready for writing, <code>Waker::wake</code> will be called on the
waker.</p>
<p>Note that on multiple calls to <code>poll_write_ready</code> or <code>poll_write</code>, only
the <code>Waker</code> from the <code>Context</code> passed to the most recent call is
scheduled to receive a wakeup. (However, <code>poll_read_ready</code> retains a
second, independent waker.)</p>
<p>This function is intended for cases where creating and pinning a future
via <a href="struct.UnixStream.html#method.writable"><code>writable</code></a> is not feasible. Where possible, using <a href="struct.UnixStream.html#method.writable"><code>writable</code></a> is
preferred, as this supports polling from multiple tasks at once.</p>
<h5 id="return-value-1" class="section-header"><a href="#return-value-1">Return value</a></h5>
<p>The function returns:</p>
<ul>
<li><code>Poll::Pending</code> if the unix stream is not ready for writing.</li>
<li><code>Poll::Ready(Ok(()))</code> if the unix stream is ready for writing.</li>
<li><code>Poll::Ready(Err(e))</code> if an error is encountered.</li>
</ul>
<h5 id="errors-1" class="section-header"><a href="#errors-1">Errors</a></h5>
<p>This function may encounter any standard I/O error except <code>WouldBlock</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_write" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#588-592" title="goto source code">[src]</a></div><a href="#method.try_write" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_write" class="fnname">try_write</a>(&amp;self, buf: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;</h4></div></summary><div class="docblock"><p>Tries to write a buffer to the stream, returning how many bytes were
written.</p>
<p>The function will attempt to write the entire contents of <code>buf</code>, but
only part of the buffer may be written.</p>
<p>This function is usually paired with <code>writable()</code>.</p>
<h5 id="return-2" class="section-header"><a href="#return-2">Return</a></h5>
<p>If data is successfully written, <code>Ok(n)</code> is returned, where <code>n</code> is the
number of bytes written. If the stream is not ready to write data,
<code>Err(io::ErrorKind::WouldBlock)</code> is returned.</p>
<h5 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be writable</span>
<span class="ident">stream</span>.<span class="ident">writable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Try to write data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_write</span>(<span class="string">b&quot;hello world&quot;</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="kw">break</span>;
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_write_vectored" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#650-654" title="goto source code">[src]</a></div><a href="#method.try_write_vectored" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_write_vectored" class="fnname">try_write_vectored</a>(&amp;self, buf: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;[</a><a class="struct" href="https://doc.rust-lang.org/1.59.0/std/io/struct.IoSlice.html" title="struct std::io::IoSlice">IoSlice</a>&lt;'_&gt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;</h4></div></summary><div class="docblock"><p>Tries to write several buffers to the stream, returning how many bytes
were written.</p>
<p>Data is written from each buffer in order, with the final buffer read
from possible being only partially consumed. This method behaves
equivalently to a single call to <a href="struct.UnixStream.html#method.try_write"><code>try_write()</code></a> with concatenated
buffers.</p>
<p>This function is usually paired with <code>writable()</code>.</p>
<h5 id="return-3" class="section-header"><a href="#return-3">Return</a></h5>
<p>If data is successfully written, <code>Ok(n)</code> is returned, where <code>n</code> is the
number of bytes written. If the stream is not ready to write data,
<code>Err(io::ErrorKind::WouldBlock)</code> is returned.</p>
<h5 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="comment">// Connect to a peer</span>
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">let</span> <span class="ident">bufs</span> <span class="op">=</span> [<span class="ident">io::IoSlice::new</span>(<span class="string">b&quot;hello &quot;</span>), <span class="ident">io::IoSlice::new</span>(<span class="string">b&quot;world&quot;</span>)];
<span class="kw">loop</span> {
<span class="comment">// Wait for the socket to be writable</span>
<span class="ident">stream</span>.<span class="ident">writable</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="comment">// Try to write data, this may still fail with `WouldBlock`</span>
<span class="comment">// if the readiness event is a false positive.</span>
<span class="kw">match</span> <span class="ident">stream</span>.<span class="ident">try_write_vectored</span>(<span class="kw-2">&amp;</span><span class="ident">bufs</span>) {
<span class="prelude-val">Ok</span>(<span class="ident">n</span>) =&gt; {
<span class="kw">break</span>;
}
<span class="prelude-val">Err</span>(<span class="kw-2">ref</span> <span class="ident">e</span>) <span class="kw">if</span> <span class="ident">e</span>.<span class="ident">kind</span>() <span class="op">==</span> <span class="ident">io::ErrorKind::WouldBlock</span> =&gt; {
<span class="kw">continue</span>;
}
<span class="prelude-val">Err</span>(<span class="ident">e</span>) =&gt; {
<span class="kw">return</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>.<span class="ident">into</span>());
}
}
}
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_io" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#683-689" title="goto source code">[src]</a></div><a href="#method.try_io" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_io" class="fnname">try_io</a>&lt;R&gt;(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;interest: <a class="struct" href="../io/struct.Interest.html" title="struct tokio::io::Interest">Interest</a>, <br>&nbsp;&nbsp;&nbsp;&nbsp;f: impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;R&gt;<br>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;R&gt;</h4></div></summary><div class="docblock"><p>Tries to read or write from the socket using a user-provided IO operation.</p>
<p>If the socket is ready, the provided closure is called. The closure
should attempt to perform IO operation from the socket by manually
calling the appropriate syscall. If the operation fails because the
socket is not actually ready, then the closure should return a
<code>WouldBlock</code> error and the readiness flag is cleared. The return value
of the closure is then returned by <code>try_io</code>.</p>
<p>If the socket is not ready, then the closure is not called
and a <code>WouldBlock</code> error is returned.</p>
<p>The closure should only return a <code>WouldBlock</code> error if it has performed
an IO operation on the socket that failed due to the socket not being
ready. Returning a <code>WouldBlock</code> error in any other situation will
incorrectly clear the readiness flag, which can cause the socket to
behave incorrectly.</p>
<p>The closure should not perform the IO operation using any of the methods
defined on the Tokio <code>UnixStream</code> type, as this will mess with the
readiness flag and can cause the socket to behave incorrectly.</p>
<p>Usually, <a href="struct.UnixStream.html#method.readable"><code>readable()</code></a>, <a href="struct.UnixStream.html#method.writable"><code>writable()</code></a> or <a href="struct.UnixStream.html#method.ready"><code>ready()</code></a> is used with this function.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_std" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#705-710" title="goto source code">[src]</a></div><a href="#method.from_std" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.from_std" class="fnname">from_std</a>(stream: <a class="struct" href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html" title="struct std::os::unix::net::stream::UnixStream">UnixStream</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt;</h4></div></summary><div class="docblock"><p>Creates new <code>UnixStream</code> from a <code>std::os::unix::net::UnixStream</code>.</p>
<p>This function is intended to be used to wrap a UnixStream from the
standard library in the Tokio equivalent. The conversion assumes
nothing about the underlying stream; it is left up to the user to set
it in non-blocking mode.</p>
<h5 id="panics" class="section-header"><a href="#panics">Panics</a></h5>
<p>This function panics if thread-local runtime is not set.</p>
<p>The runtime is usually set implicitly when this function is called
from a future driven by a tokio runtime, otherwise runtime can be set
explicitly with <a href="../runtime/struct.Runtime.html#method.enter"><code>Runtime::enter</code></a> function.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_std" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#750-755" title="goto source code">[src]</a></div><a href="#method.into_std" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.into_std" class="fnname">into_std</a>(self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html" title="struct std::os::unix::net::stream::UnixStream">UnixStream</a>&gt;</h4></div></summary><div class="docblock"><p>Turns a <a href="struct.UnixStream.html"><code>tokio::net::UnixStream</code></a> into a <a href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html"><code>std::os::unix::net::UnixStream</code></a>.</p>
<p>The returned <a href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html"><code>std::os::unix::net::UnixStream</code></a> will have nonblocking
mode set as <code>true</code>. Use <a href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html#method.set_nonblocking"><code>set_nonblocking</code></a> to change the blocking
mode if needed.</p>
<h5 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::error::Error</span>;
<span class="kw">use</span> <span class="ident">std::io::Read</span>;
<span class="kw">use</span> <span class="ident">tokio::net::UnixListener</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span>(), <span class="ident">Box</span><span class="op">&lt;</span><span class="kw">dyn</span> <span class="ident">Error</span><span class="op">&gt;</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">data</span> <span class="op">=</span> [<span class="number">0u8</span>; <span class="number">12</span>];
<span class="kw">let</span> <span class="ident">listener</span> <span class="op">=</span> <span class="ident">UnixListener::bind</span>(<span class="kw-2">&amp;</span><span class="ident">bind_path</span>)<span class="question-mark">?</span>;
<span class="kw">let</span> (<span class="ident">tokio_unix_stream</span>, <span class="kw">_</span>) <span class="op">=</span> <span class="ident">listener</span>.<span class="ident">accept</span>().<span class="kw">await</span><span class="question-mark">?</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">std_unix_stream</span> <span class="op">=</span> <span class="ident">tokio_unix_stream</span>.<span class="ident">into_std</span>()<span class="question-mark">?</span>;
<span class="ident">std_unix_stream</span>.<span class="ident">set_nonblocking</span>(<span class="bool-val">false</span>)<span class="question-mark">?</span>;
<span class="ident">std_unix_stream</span>.<span class="ident">read_exact</span>(<span class="kw-2">&amp;mut</span> <span class="ident">data</span>)<span class="question-mark">?</span>;
<span class="prelude-val">Ok</span>(())
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.pair" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#762-768" title="goto source code">[src]</a></div><a href="#method.pair" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.pair" class="fnname">pair</a>() -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">(</a><a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>, <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">)</a>&gt;</h4></div></summary><div class="docblock"><p>Creates an unnamed pair of connected sockets.</p>
<p>This function will create a pair of interconnected Unix sockets for
communicating back and forth between one another. Each socket will
be associated with the default event loop’s handle.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.local_addr" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#791-793" title="goto source code">[src]</a></div><a href="#method.local_addr" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.local_addr" class="fnname">local_addr</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="unix/struct.SocketAddr.html" title="struct tokio::net::unix::SocketAddr">SocketAddr</a>&gt;</h4></div></summary><div class="docblock"><p>Returns the socket address of the local half of this connection.</p>
<h5 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="macro">println!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">stream</span>.<span class="ident">local_addr</span>()<span class="question-mark">?</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.peer_addr" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#811-813" title="goto source code">[src]</a></div><a href="#method.peer_addr" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.peer_addr" class="fnname">peer_addr</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="unix/struct.SocketAddr.html" title="struct tokio::net::unix::SocketAddr">SocketAddr</a>&gt;</h4></div></summary><div class="docblock"><p>Returns the socket address of the remote half of this connection.</p>
<h5 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::net::UnixStream</span>;
<span class="kw">let</span> <span class="ident">dir</span> <span class="op">=</span> <span class="ident">tempfile::tempdir</span>().<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">bind_path</span> <span class="op">=</span> <span class="ident">dir</span>.<span class="ident">path</span>().<span class="ident">join</span>(<span class="string">&quot;bind_path&quot;</span>);
<span class="kw">let</span> <span class="ident">stream</span> <span class="op">=</span> <span class="ident">UnixStream::connect</span>(<span class="ident">bind_path</span>).<span class="kw">await</span><span class="question-mark">?</span>;
<span class="macro">println!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">stream</span>.<span class="ident">peer_addr</span>()<span class="question-mark">?</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.peer_cred" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#816-818" title="goto source code">[src]</a></div><a href="#method.peer_cred" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.peer_cred" class="fnname">peer_cred</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="struct" href="unix/struct.UCred.html" title="struct tokio::net::unix::UCred">UCred</a>&gt;</h4></div></summary><div class="docblock"><p>Returns effective credentials of the process which called <code>connect</code> or <code>pair</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.take_error" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#821-823" title="goto source code">[src]</a></div><a href="#method.take_error" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.take_error" class="fnname">take_error</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="enum" href="https://doc.rust-lang.org/1.59.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;<a class="struct" href="https://doc.rust-lang.org/1.59.0/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Returns the value of the <code>SO_ERROR</code> option.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.split" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#844-846" title="goto source code">[src]</a></div><a href="#method.split" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.split" class="fnname">split</a>&lt;'a&gt;(&amp;'a mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">(</a><a class="struct" href="unix/struct.ReadHalf.html" title="struct tokio::net::unix::ReadHalf">ReadHalf</a>&lt;'a&gt;, <a class="struct" href="unix/struct.WriteHalf.html" title="struct tokio::net::unix::WriteHalf">WriteHalf</a>&lt;'a&gt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">)</a></h4></div></summary><div class="docblock"><p>Splits a <code>UnixStream</code> into a read half and a write half, which can be used
to read and write the stream concurrently.</p>
<p>This method is more efficient than <a href="struct.UnixStream.html#method.into_split"><code>into_split</code></a>, but the halves cannot be
moved into independently spawned tasks.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_split" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#859-861" title="goto source code">[src]</a></div><a href="#method.into_split" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.into_split" class="fnname">into_split</a>(self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">(</a><a class="struct" href="unix/struct.OwnedReadHalf.html" title="struct tokio::net::unix::OwnedReadHalf">OwnedReadHalf</a>, <a class="struct" href="unix/struct.OwnedWriteHalf.html" title="struct tokio::net::unix::OwnedWriteHalf">OwnedWriteHalf</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.tuple.html">)</a></h4></div></summary><div class="docblock"><p>Splits a <code>UnixStream</code> into a read half and a write half, which can be used
to read and write the stream concurrently.</p>
<p>Unlike <a href="struct.UnixStream.html#method.split"><code>split</code></a>, the owned halves can be moved to separate tasks, however
this comes at the cost of a heap allocation.</p>
<p><strong>Note:</strong> Dropping the write half will shut down the write half of the
stream. This is equivalent to calling <a href="fn@crate::io::AsyncWriteExt::shutdown"><code>shutdown()</code></a> on the <code>UnixStream</code>.</p>
</div></details></div></details><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsRawFd" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#956-960" title="goto source code">[src]</a></div><a href="#impl-AsRawFd" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/std/os/fd/raw/trait.AsRawFd.html" title="trait std::os::fd::raw::AsRawFd">AsRawFd</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_raw_fd" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#957-959" title="goto source code">[src]</a></div><a href="#method.as_raw_fd" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd" class="fnname">as_raw_fd</a>(&amp;self) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/os/fd/raw/type.RawFd.html" title="type std::os::fd::raw::RawFd">RawFd</a></h4></div></summary><div class='docblock'><p>Extracts the raw file descriptor. <a href="https://doc.rust-lang.org/1.59.0/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsRef%3CUnixStream%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split.rs.html#295-299" title="goto source code">[src]</a></div><a href="#impl-AsRef%3CUnixStream%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt; for <a class="struct" href="unix/struct.ReadHalf.html" title="struct tokio::net::unix::ReadHalf">ReadHalf</a>&lt;'_&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ref" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split.rs.html#296-298" title="goto source code">[src]</a></div><a href="#method.as_ref" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&amp;self) -&gt; &amp;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsRef%3CUnixStream%3E-1" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split.rs.html#301-305" title="goto source code">[src]</a></div><a href="#impl-AsRef%3CUnixStream%3E-1" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt; for <a class="struct" href="unix/struct.WriteHalf.html" title="struct tokio::net::unix::WriteHalf">WriteHalf</a>&lt;'_&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ref-1" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split.rs.html#302-304" title="goto source code">[src]</a></div><a href="#method.as_ref-1" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&amp;self) -&gt; &amp;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsRef%3CUnixStream%3E-2" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split_owned.rs.html#383-387" title="goto source code">[src]</a></div><a href="#impl-AsRef%3CUnixStream%3E-2" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt; for <a class="struct" href="unix/struct.OwnedReadHalf.html" title="struct tokio::net::unix::OwnedReadHalf">OwnedReadHalf</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ref-2" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split_owned.rs.html#384-386" title="goto source code">[src]</a></div><a href="#method.as_ref-2" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&amp;self) -&gt; &amp;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsRef%3CUnixStream%3E-3" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split_owned.rs.html#389-393" title="goto source code">[src]</a></div><a href="#impl-AsRef%3CUnixStream%3E-3" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a>&lt;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a>&gt; for <a class="struct" href="unix/struct.OwnedWriteHalf.html" title="struct tokio::net::unix::OwnedWriteHalf">OwnedWriteHalf</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ref-3" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/split_owned.rs.html#390-392" title="goto source code">[src]</a></div><a href="#method.as_ref-3" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.AsRef.html#tymethod.as_ref" class="fnname">as_ref</a>(&amp;self) -&gt; &amp;<a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsyncRead" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#876-884" title="goto source code">[src]</a></div><a href="#impl-AsyncRead" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../io/trait.AsyncRead.html" title="trait tokio::io::AsyncRead">AsyncRead</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_read" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#877-883" title="goto source code">[src]</a></div><a href="#method.poll_read" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncRead.html#tymethod.poll_read" class="fnname">poll_read</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>Self&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;cx: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;buf: &amp;mut <a class="struct" href="../io/struct.ReadBuf.html" title="struct tokio::io::ReadBuf">ReadBuf</a>&lt;'_&gt;<br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class='docblock'><p>Attempts to read from the <code>AsyncRead</code> into <code>buf</code>. <a href="../io/trait.AsyncRead.html#tymethod.poll_read">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-AsyncWrite" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#886-915" title="goto source code">[src]</a></div><a href="#impl-AsyncWrite" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="../io/trait.AsyncWrite.html" title="trait tokio::io::AsyncWrite">AsyncWrite</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_write" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#887-893" title="goto source code">[src]</a></div><a href="#method.poll_write" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncWrite.html#tymethod.poll_write" class="fnname">poll_write</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>Self&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;cx: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;buf: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;&gt;</h4></div></summary><div class='docblock'><p>Attempt to write bytes from <code>buf</code> into the object. <a href="../io/trait.AsyncWrite.html#tymethod.poll_write">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_write_vectored" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#895-901" title="goto source code">[src]</a></div><a href="#method.poll_write_vectored" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncWrite.html#method.poll_write_vectored" class="fnname">poll_write_vectored</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>Self&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;cx: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;, <br>&nbsp;&nbsp;&nbsp;&nbsp;bufs: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">&amp;[</a><a class="struct" href="https://doc.rust-lang.org/1.59.0/std/io/struct.IoSlice.html" title="struct std::io::IoSlice">IoSlice</a>&lt;'_&gt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.slice.html">]</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;&gt;</h4></div></summary><div class='docblock'><p>Like <a href="../io/trait.AsyncWrite.html#tymethod.poll_write"><code>poll_write</code></a>, except that it writes from a slice of buffers. <a href="../io/trait.AsyncWrite.html#method.poll_write_vectored">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_write_vectored" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#903-905" title="goto source code">[src]</a></div><a href="#method.is_write_vectored" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncWrite.html#method.is_write_vectored" class="fnname">is_write_vectored</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class='docblock'><p>Determines if this writer has an efficient <a href="../io/trait.AsyncWrite.html#method.poll_write_vectored"><code>poll_write_vectored</code></a>
implementation. <a href="../io/trait.AsyncWrite.html#method.is_write_vectored">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_flush" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#907-909" title="goto source code">[src]</a></div><a href="#method.poll_flush" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncWrite.html#tymethod.poll_flush" class="fnname">poll_flush</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>Self&gt;, _: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class='docblock'><p>Attempts to flush the object, ensuring that any buffered data reach
their destination. <a href="../io/trait.AsyncWrite.html#tymethod.poll_flush">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.poll_shutdown" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#911-914" title="goto source code">[src]</a></div><a href="#method.poll_shutdown" class="anchor"></a><h4 class="code-header">fn <a href="../io/trait.AsyncWrite.html#tymethod.poll_shutdown" class="fnname">poll_shutdown</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>Self&gt;, _: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/task/wake/struct.Context.html" title="struct core::task::wake::Context">Context</a>&lt;'_&gt;) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/task/poll/enum.Poll.html" title="enum core::task::poll::Poll">Poll</a>&lt;<a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class='docblock'><p>Initiates or attempts to shut down this writer, returning success when
the I/O connection has completely shut down. <a href="../io/trait.AsyncWrite.html#tymethod.poll_shutdown">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Debug" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#950-954" title="goto source code">[src]</a></div><a href="#impl-Debug" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#951-953" title="goto source code">[src]</a></div><a href="#method.fmt" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fnname">fmt</a>(&amp;self, f: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>&lt;'_&gt;) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></div></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-TryFrom%3CUnixStream%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#864-874" title="goto source code">[src]</a></div><a href="#impl-TryFrom%3CUnixStream%3E" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;<a class="struct" href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html" title="struct std::os::unix::net::stream::UnixStream">UnixStream</a>&gt; for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_from" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/net/unix/stream.rs.html#871-873" title="goto source code">[src]</a></div><a href="#method.try_from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(stream: <a class="struct" href="https://doc.rust-lang.org/1.59.0/std/os/unix/net/stream/struct.UnixStream.html" title="struct std::os::unix::net::stream::UnixStream">UnixStream</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/std/io/error/type.Result.html" title="type std::io::error::Result">Result</a>&lt;Self&gt;</h4></div></summary><div class="docblock"><p>Consumes stream, returning the tokio I/O object.</p>
<p>This is equivalent to
<a href="struct.UnixStream.html#method.from_std"><code>UnixStream::from_std(stream)</code></a>.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error" class="type trait-impl has-srclink"><a href="#associatedtype.Error" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="struct" href="https://doc.rust-lang.org/1.59.0/std/io/error/struct.Error.html" title="struct std::io::error::Error">Error</a></h4></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details></div></details></div><h2 id="synthetic-implementations" class="small-section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor"></a></h2><div id="synthetic-implementations-list"><div id="impl-RefUnwindSafe" class="impl has-srclink"><div class="rightside"></div><a href="#impl-RefUnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div><div id="impl-Send" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Send" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div><div id="impl-Sync" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Sync" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div><div id="impl-Unpin" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Unpin" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div><div id="impl-UnwindSafe" class="impl has-srclink"><div class="rightside"></div><a href="#impl-UnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.UnixStream.html" title="struct tokio::net::UnixStream">UnixStream</a></h3></div></div><h2 id="blanket-implementations" class="small-section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor"></a></h2><div id="blanket-implementations-list"><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Any" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/any.rs.html#132-136" title="goto source code">[src]</a></div><a href="#impl-Any" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.type_id" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/any.rs.html#133" title="goto source code">[src]</a></div><a href="#method.type_id" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html#tymethod.type_id" class="fnname">type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></div></summary><div class='docblock'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Borrow%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#209-214" title="goto source code">[src]</a></div><a href="#impl-Borrow%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#211" title="goto source code">[src]</a></div><a href="#method.borrow" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;</a>T</h4></div></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-BorrowMut%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#218-222" title="goto source code">[src]</a></div><a href="#impl-BorrowMut%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow_mut" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#219" title="goto source code">[src]</a></div><a href="#method.borrow_mut" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fnname">borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>T</h4></div></summary><div class='docblock'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-From%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#550-554" title="goto source code">[src]</a></div><a href="#impl-From%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#551" title="goto source code">[src]</a></div><a href="#method.from" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: T) -&gt; T</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Into%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#538-545" title="goto source code">[src]</a></div><a href="#impl-Into%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#542" title="goto source code">[src]</a></div><a href="#method.into" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html#tymethod.into" class="fnname">into</a>(self) -&gt; U</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-TryFrom%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#588-597" title="goto source code">[src]</a></div><a href="#impl-TryFrom%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error-2" class="type trait-impl has-srclink"><a href="#associatedtype.Error-2" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_from-1" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#594" title="goto source code">[src]</a></div><a href="#method.try_from-1" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/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/1.59.0/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/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-TryInto%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#574-583" title="goto source code">[src]</a></div><a href="#impl-TryInto%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error-1" class="type trait-impl has-srclink"><a href="#associatedtype.Error-1" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.59.0/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/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_into" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#580" title="goto source code">[src]</a></div><a href="#method.try_into" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fnname">try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/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/1.59.0/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/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details></div></section><section id="search" class="content hidden"></section></div></main><div id="rustdoc-vars" data-root-path="../../" data-current-crate="tokio" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.59.0 (9d1b2106e 2022-02-23)" ></div>
</body></html>
Reference in New Issue View Git Blame Copy Permalink