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/sync/struct.RwLock.html

385 lines
71 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="An asynchronous reader-writer lock."><meta name="keywords" content="rust, rustlang, rust-lang, RwLock"><title>RwLock in tokio::sync - 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 RwLock</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.blocking_read">blocking_read</a><a href="#method.blocking_write">blocking_write</a><a href="#method.get_mut">get_mut</a><a href="#method.into_inner">into_inner</a><a href="#method.new">new</a><a href="#method.read">read</a><a href="#method.read_owned">read_owned</a><a href="#method.try_read">try_read</a><a href="#method.try_read_owned">try_read_owned</a><a href="#method.try_write">try_write</a><a href="#method.try_write_owned">try_write_owned</a><a href="#method.with_max_readers">with_max_readers</a><a href="#method.write">write</a><a href="#method.write_owned">write_owned</a></div><h3 class="sidebar-title"><a href="#trait-implementations">Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-From%3CT%3E">From&lt;T&gt;</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</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-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%3C!%3E">From&lt;!&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">sync</a></h2><div id="sidebar-vars" data-name="RwLock" 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">sync</a>::<wbr><a class="struct" href="#">RwLock</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/sync/rwlock.rs.html#90-102" title="goto source code">[src]</a></span></h1><div class="docblock item-decl"><pre class="rust struct"><code>pub struct RwLock&lt;T:&nbsp;?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; { /* fields omitted */ }</code></pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>An asynchronous reader-writer lock.</p>
<p>This type of lock allows a number of readers or at most one writer at any
point in time. The write portion of this lock typically allows modification
of the underlying data (exclusive access) and the read portion of this lock
typically allows for read-only access (shared access).</p>
<p>In comparison, a <a href="struct.Mutex.html"><code>Mutex</code></a> does not distinguish between readers or writers
that acquire the lock, therefore causing any tasks waiting for the lock to
become available to yield. An <code>RwLock</code> will allow any number of readers to
acquire the lock as long as a writer is not holding the lock.</p>
<p>The priority policy of Tokio’s read-write lock is <em>fair</em> (or
<a href="https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock#Priority_policies"><em>write-preferring</em></a>), in order to ensure that readers cannot starve
writers. Fairness is ensured using a first-in, first-out queue for the tasks
awaiting the lock; if a task that wishes to acquire the write lock is at the
head of the queue, read locks will not be given out until the write lock has
been released. This is in contrast to the Rust standard library’s
<code>std::sync::RwLock</code>, where the priority policy is dependent on the
operating system’s implementation.</p>
<p>The type parameter <code>T</code> represents the data that this lock protects. It is
required that <code>T</code> satisfies <a href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html"><code>Send</code></a> to be shared across threads. The RAII guards
returned from the locking methods implement <a href="https://doc.rust-lang.org/1.59.0/core/ops/deref/trait.Deref.html"><code>Deref</code></a>
(and <a href="https://doc.rust-lang.org/1.59.0/core/ops/deref/trait.DerefMut.html"><code>DerefMut</code></a>
for the <code>write</code> methods) to allow access to the content of the lock.</p>
<h2 id="examples" class="section-header"><a href="#examples">Examples</a></h2>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">RwLock::new</span>(<span class="number">5</span>);
<span class="comment">// many reader locks can be held at once</span>
{
<span class="kw">let</span> <span class="ident">r1</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="kw">let</span> <span class="ident">r2</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">r1</span>, <span class="number">5</span>);
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">r2</span>, <span class="number">5</span>);
} <span class="comment">// read locks are dropped at this point</span>
<span class="comment">// only one write lock may be held, however</span>
{
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">w</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">write</span>().<span class="kw">await</span>;
<span class="kw-2">*</span><span class="ident">w</span> <span class="op">+</span><span class="op">=</span> <span class="number">1</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">w</span>, <span class="number">6</span>);
} <span class="comment">// write lock is dropped here</span>
}</code></pre></div>
</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/sync/rwlock.rs.html#195-1063" title="goto source code">[src]</a></div><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl&lt;T:&nbsp;?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.new" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#206-255" title="goto source code">[src]</a></div><a href="#method.new" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.new" class="fnname">new</a>(value: T) -&gt; <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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></h4></div></summary><div class="docblock"><p>Creates a new instance of an <code>RwLock&lt;T&gt;</code> which is unlocked.</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::sync::RwLock</span>;
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">RwLock::new</span>(<span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.with_max_readers" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#272-328" title="goto source code">[src]</a></div><a href="#method.with_max_readers" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.with_max_readers" class="fnname">with_max_readers</a>(value: T, max_reads: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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></h4></div></summary><div class="docblock"><p>Creates a new instance of an <code>RwLock&lt;T&gt;</code> which is unlocked
and allows a maximum of <code>max_reads</code> concurrent readers.</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::sync::RwLock</span>;
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">RwLock::with_max_readers</span>(<span class="number">5</span>, <span class="number">1024</span>);</code></pre></div>
<h5 id="panics" class="section-header"><a href="#panics">Panics</a></h5>
<p>Panics if <code>max_reads</code> is more than <code>u32::MAX &gt;&gt; 3</code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.read" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#425-460" title="goto source code">[src]</a></div><a href="#method.read" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.read" class="fnname">read</a>(&amp;self) -&gt; <a class="struct" href="struct.RwLockReadGuard.html" title="struct tokio::sync::RwLockReadGuard">RwLockReadGuard</a>&lt;'_, T&gt;</h4></div></summary><div class="docblock"><p>Locks this <code>RwLock</code> with shared read access, causing the current task
to yield until the lock has been acquired.</p>
<p>The calling task will yield until there are no writers which hold the
lock. There may be other readers inside the lock when the task resumes.</p>
<p>Note that under the priority policy of <a href="struct.RwLock.html" title="RwLock"><code>RwLock</code></a>, read locks are not
granted until prior write locks, to prevent starvation. Therefore
deadlock may occur if a read lock is held by the current task, a write
lock attempt is made, and then a subsequent read lock attempt is made
by the current task.</p>
<p>Returns an RAII guard which will drop this read access of the <code>RwLock</code>
when dropped.</p>
<h5 id="cancel-safety" class="section-header"><a href="#cancel-safety">Cancel safety</a></h5>
<p>This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to <code>read</code> makes you lose your place in
the queue.</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">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">c_lock</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">n</span>, <span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="comment">// While main has an active read lock, we acquire one too.</span>
<span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="ident">c_lock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">r</span>, <span class="number">1</span>);
}).<span class="kw">await</span>.<span class="ident">expect</span>(<span class="string">&quot;The spawned task has panicked&quot;</span>);
<span class="comment">// Drop the guard after the spawned task finishes.</span>
<span class="ident">drop</span>(<span class="ident">n</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.blocking_read" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#510-512" title="goto source code">[src]</a></div><a href="#method.blocking_read" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.blocking_read" class="fnname">blocking_read</a>(&amp;self) -&gt; <a class="struct" href="struct.RwLockReadGuard.html" title="struct tokio::sync::RwLockReadGuard">RwLockReadGuard</a>&lt;'_, T&gt;</h4></div></summary><div class="docblock"><p>Blockingly locks this <code>RwLock</code> with shared read access.</p>
<p>This method is intended for use cases where you
need to use this rwlock in asynchronous code as well as in synchronous code.</p>
<p>Returns an RAII guard which will drop the read access of this <code>RwLock</code> when dropped.</p>
<h5 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h5>
<p>This function panics if called within an asynchronous execution context.</p>
<ul>
<li>If you find yourself in an asynchronous execution context and needing
to call some (synchronous) function which performs one of these
<code>blocking_</code> operations, then consider wrapping that call inside
<a href="../runtime/struct.Handle.html#method.spawn_blocking" title="crate::runtime::Handle::spawn_blocking"><code>spawn_blocking()</code></a>
(or <a href="../task/fn.block_in_place.html" title="crate::task::block_in_place"><code>block_in_place()</code></a>).</li>
</ul>
<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">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">rwlock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">write_lock</span> <span class="op">=</span> <span class="ident">rwlock</span>.<span class="ident">write</span>().<span class="kw">await</span>;
<span class="kw">let</span> <span class="ident">blocking_task</span> <span class="op">=</span> <span class="ident">tokio::task::spawn_blocking</span>({
<span class="kw">let</span> <span class="ident">rwlock</span> <span class="op">=</span> <span class="ident">Arc::clone</span>(<span class="kw-2">&amp;</span><span class="ident">rwlock</span>);
<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="comment">// This shall block until the `write_lock` is released.</span>
<span class="kw">let</span> <span class="ident">read_lock</span> <span class="op">=</span> <span class="ident">rwlock</span>.<span class="ident">blocking_read</span>();
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">read_lock</span>, <span class="number">0</span>);
}
});
<span class="kw-2">*</span><span class="ident">write_lock</span> <span class="op">-</span><span class="op">=</span> <span class="number">1</span>;
<span class="ident">drop</span>(<span class="ident">write_lock</span>); <span class="comment">// release the lock.</span>
<span class="comment">// Await the completion of the blocking task.</span>
<span class="ident">blocking_task</span>.<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// Assert uncontended.</span>
<span class="macro">assert!</span>(<span class="ident">rwlock</span>.<span class="ident">try_write</span>().<span class="ident">is_ok</span>());
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.read_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#565-603" title="goto source code">[src]</a></div><a href="#method.read_owned" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.read_owned" class="fnname">read_owned</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="struct alloc::sync::Arc">Arc</a>&lt;Self&gt;) -&gt; <a class="struct" href="struct.OwnedRwLockReadGuard.html" title="struct tokio::sync::OwnedRwLockReadGuard">OwnedRwLockReadGuard</a>&lt;T&gt;</h4></div></summary><div class="docblock"><p>Locks this <code>RwLock</code> with shared read access, causing the current task
to yield until the lock has been acquired.</p>
<p>The calling task will yield until there are no writers which hold the
lock. There may be other readers inside the lock when the task resumes.</p>
<p>This method is identical to <a href="struct.RwLock.html#method.read" title="RwLock::read"><code>RwLock::read</code></a>, except that the returned
guard references the <code>RwLock</code> with an <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="Arc"><code>Arc</code></a> rather than by borrowing
it. Therefore, the <code>RwLock</code> must be wrapped in an <code>Arc</code> to call this
method, and the guard will live for the <code>'static</code> lifetime, as it keeps
the <code>RwLock</code> alive by holding an <code>Arc</code>.</p>
<p>Note that under the priority policy of <a href="struct.RwLock.html" title="RwLock"><code>RwLock</code></a>, read locks are not
granted until prior write locks, to prevent starvation. Therefore
deadlock may occur if a read lock is held by the current task, a write
lock attempt is made, and then a subsequent read lock attempt is made
by the current task.</p>
<p>Returns an RAII guard which will drop this read access of the <code>RwLock</code>
when dropped.</p>
<h5 id="cancel-safety-1" class="section-header"><a href="#cancel-safety-1">Cancel safety</a></h5>
<p>This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to <code>read_owned</code> makes you lose your
place in the queue.</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">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">c_lock</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">read_owned</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">n</span>, <span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="comment">// While main has an active read lock, we acquire one too.</span>
<span class="kw">let</span> <span class="ident">r</span> <span class="op">=</span> <span class="ident">c_lock</span>.<span class="ident">read_owned</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">r</span>, <span class="number">1</span>);
}).<span class="kw">await</span>.<span class="ident">expect</span>(<span class="string">&quot;The spawned task has panicked&quot;</span>);
<span class="comment">// Drop the guard after the spawned task finishes.</span>
<span class="ident">drop</span>(<span class="ident">n</span>);
}</code></pre></div>
</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/sync/rwlock.rs.html#637-660" 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) -&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;<a class="struct" href="struct.RwLockReadGuard.html" title="struct tokio::sync::RwLockReadGuard">RwLockReadGuard</a>&lt;'_, T&gt;, <a class="struct" href="struct.TryLockError.html" title="struct tokio::sync::TryLockError">TryLockError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to acquire this <code>RwLock</code> with shared read access.</p>
<p>If the access couldn’t be acquired immediately, returns <a href="struct.TryLockError.html"><code>TryLockError</code></a>.
Otherwise, an RAII guard is returned which will release read access
when dropped.</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">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">c_lock</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">try_read</span>().<span class="ident">unwrap</span>();
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">v</span>, <span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="comment">// While main has an active read lock, we acquire one too.</span>
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">c_lock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">n</span>, <span class="number">1</span>);
}).<span class="kw">await</span>.<span class="ident">expect</span>(<span class="string">&quot;The spawned task has panicked&quot;</span>);
<span class="comment">// Drop the guard when spawned task finishes.</span>
<span class="ident">drop</span>(<span class="ident">v</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_read_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#700-726" title="goto source code">[src]</a></div><a href="#method.try_read_owned" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_read_owned" class="fnname">try_read_owned</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="struct alloc::sync::Arc">Arc</a>&lt;Self&gt;<br>) -&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;<a class="struct" href="struct.OwnedRwLockReadGuard.html" title="struct tokio::sync::OwnedRwLockReadGuard">OwnedRwLockReadGuard</a>&lt;T&gt;, <a class="struct" href="struct.TryLockError.html" title="struct tokio::sync::TryLockError">TryLockError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to acquire this <code>RwLock</code> with shared read access.</p>
<p>If the access couldn’t be acquired immediately, returns <a href="struct.TryLockError.html"><code>TryLockError</code></a>.
Otherwise, an RAII guard is returned which will release read access
when dropped.</p>
<p>This method is identical to <a href="struct.RwLock.html#method.try_read" title="RwLock::try_read"><code>RwLock::try_read</code></a>, except that the
returned guard references the <code>RwLock</code> with an <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="Arc"><code>Arc</code></a> rather than by
borrowing it. Therefore, the <code>RwLock</code> must be wrapped in an <code>Arc</code> to
call this method, and the guard will live for the <code>'static</code> lifetime,
as it keeps the <code>RwLock</code> alive by holding an <code>Arc</code>.</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::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">c_lock</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">try_read_owned</span>().<span class="ident">unwrap</span>();
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">v</span>, <span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="comment">// While main has an active read lock, we acquire one too.</span>
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">c_lock</span>.<span class="ident">read_owned</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">n</span>, <span class="number">1</span>);
}).<span class="kw">await</span>.<span class="ident">expect</span>(<span class="string">&quot;The spawned task has panicked&quot;</span>);
<span class="comment">// Drop the guard when spawned task finishes.</span>
<span class="ident">drop</span>(<span class="ident">v</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.write" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#756-792" title="goto source code">[src]</a></div><a href="#method.write" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.write" class="fnname">write</a>(&amp;self) -&gt; <a class="struct" href="struct.RwLockWriteGuard.html" title="struct tokio::sync::RwLockWriteGuard">RwLockWriteGuard</a>&lt;'_, T&gt;</h4></div></summary><div class="docblock"><p>Locks this <code>RwLock</code> with exclusive write access, causing the current
task to yield until the lock has been acquired.</p>
<p>The calling task will yield while other writers or readers currently
have access to the lock.</p>
<p>Returns an RAII guard which will drop the write access of this <code>RwLock</code>
when dropped.</p>
<h5 id="cancel-safety-2" class="section-header"><a href="#cancel-safety-2">Cancel safety</a></h5>
<p>This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to <code>write</code> makes you lose your place
in the queue.</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::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">RwLock::new</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">write</span>().<span class="kw">await</span>;
<span class="kw-2">*</span><span class="ident">n</span> <span class="op">=</span> <span class="number">2</span>;
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.blocking_write" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#844-846" title="goto source code">[src]</a></div><a href="#method.blocking_write" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.blocking_write" class="fnname">blocking_write</a>(&amp;self) -&gt; <a class="struct" href="struct.RwLockWriteGuard.html" title="struct tokio::sync::RwLockWriteGuard">RwLockWriteGuard</a>&lt;'_, T&gt;</h4></div></summary><div class="docblock"><p>Blockingly locks this <code>RwLock</code> with exclusive write access.</p>
<p>This method is intended for use cases where you
need to use this rwlock in asynchronous code as well as in synchronous code.</p>
<p>Returns an RAII guard which will drop the write access of this <code>RwLock</code> when dropped.</p>
<h5 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h5>
<p>This function panics if called within an asynchronous execution context.</p>
<ul>
<li>If you find yourself in an asynchronous execution context and needing
to call some (synchronous) function which performs one of these
<code>blocking_</code> operations, then consider wrapping that call inside
<a href="../runtime/struct.Handle.html#method.spawn_blocking" title="crate::runtime::Handle::spawn_blocking"><code>spawn_blocking()</code></a>
(or <a href="../task/fn.block_in_place.html" title="crate::task::block_in_place"><code>block_in_place()</code></a>).</li>
</ul>
<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">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio</span>::{<span class="ident">sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">rwlock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">read_lock</span> <span class="op">=</span> <span class="ident">rwlock</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="kw">let</span> <span class="ident">blocking_task</span> <span class="op">=</span> <span class="ident">tokio::task::spawn_blocking</span>({
<span class="kw">let</span> <span class="ident">rwlock</span> <span class="op">=</span> <span class="ident">Arc::clone</span>(<span class="kw-2">&amp;</span><span class="ident">rwlock</span>);
<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="comment">// This shall block until the `read_lock` is released.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">write_lock</span> <span class="op">=</span> <span class="ident">rwlock</span>.<span class="ident">blocking_write</span>();
<span class="kw-2">*</span><span class="ident">write_lock</span> <span class="op">=</span> <span class="number">2</span>;
}
});
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">read_lock</span>, <span class="number">1</span>);
<span class="comment">// Release the last outstanding read lock.</span>
<span class="ident">drop</span>(<span class="ident">read_lock</span>);
<span class="comment">// Await the completion of the blocking task.</span>
<span class="ident">blocking_task</span>.<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// Assert uncontended.</span>
<span class="kw">let</span> <span class="ident">read_lock</span> <span class="op">=</span> <span class="ident">rwlock</span>.<span class="ident">try_read</span>().<span class="ident">unwrap</span>();
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">read_lock</span>, <span class="number">2</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.write_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#883-922" title="goto source code">[src]</a></div><a href="#method.write_owned" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.write_owned" class="fnname">write_owned</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="struct alloc::sync::Arc">Arc</a>&lt;Self&gt;) -&gt; <a class="struct" href="struct.OwnedRwLockWriteGuard.html" title="struct tokio::sync::OwnedRwLockWriteGuard">OwnedRwLockWriteGuard</a>&lt;T&gt;</h4></div></summary><div class="docblock"><p>Locks this <code>RwLock</code> with exclusive write access, causing the current
task to yield until the lock has been acquired.</p>
<p>The calling task will yield while other writers or readers currently
have access to the lock.</p>
<p>This method is identical to <a href="struct.RwLock.html#method.write" title="RwLock::write"><code>RwLock::write</code></a>, except that the returned
guard references the <code>RwLock</code> with an <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="Arc"><code>Arc</code></a> rather than by borrowing
it. Therefore, the <code>RwLock</code> must be wrapped in an <code>Arc</code> to call this
method, and the guard will live for the <code>'static</code> lifetime, as it keeps
the <code>RwLock</code> alive by holding an <code>Arc</code>.</p>
<p>Returns an RAII guard which will drop the write access of this <code>RwLock</code>
when dropped.</p>
<h5 id="cancel-safety-3" class="section-header"><a href="#cancel-safety-3">Cancel safety</a></h5>
<p>This method uses a queue to fairly distribute locks in the order they
were requested. Cancelling a call to <code>write_owned</code> makes you lose your
place in the queue.</p>
<h5 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">write_owned</span>().<span class="kw">await</span>;
<span class="kw-2">*</span><span class="ident">n</span> <span class="op">=</span> <span class="number">2</span>;
}</code></pre></div>
</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/sync/rwlock.rs.html#947-971" 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) -&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;<a class="struct" href="struct.RwLockWriteGuard.html" title="struct tokio::sync::RwLockWriteGuard">RwLockWriteGuard</a>&lt;'_, T&gt;, <a class="struct" href="struct.TryLockError.html" title="struct tokio::sync::TryLockError">TryLockError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to acquire this <code>RwLock</code> with exclusive write access.</p>
<p>If the access couldn’t be acquired immediately, returns <a href="struct.TryLockError.html"><code>TryLockError</code></a>.
Otherwise, an RAII guard is returned which will release write access
when dropped.</p>
<h5 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">rw</span> <span class="op">=</span> <span class="ident">RwLock::new</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">rw</span>.<span class="ident">read</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">v</span>, <span class="number">1</span>);
<span class="macro">assert!</span>(<span class="ident">rw</span>.<span class="ident">try_write</span>().<span class="ident">is_err</span>());
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_write_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#1003-1030" title="goto source code">[src]</a></div><a href="#method.try_write_owned" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_write_owned" class="fnname">try_write_owned</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;self: <a class="struct" href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="struct alloc::sync::Arc">Arc</a>&lt;Self&gt;<br>) -&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;<a class="struct" href="struct.OwnedRwLockWriteGuard.html" title="struct tokio::sync::OwnedRwLockWriteGuard">OwnedRwLockWriteGuard</a>&lt;T&gt;, <a class="struct" href="struct.TryLockError.html" title="struct tokio::sync::TryLockError">TryLockError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to acquire this <code>RwLock</code> with exclusive write access.</p>
<p>If the access couldn’t be acquired immediately, returns <a href="struct.TryLockError.html"><code>TryLockError</code></a>.
Otherwise, an RAII guard is returned which will release write access
when dropped.</p>
<p>This method is identical to <a href="struct.RwLock.html#method.try_write" title="RwLock::try_write"><code>RwLock::try_write</code></a>, except that the
returned guard references the <code>RwLock</code> with an <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html" title="Arc"><code>Arc</code></a> rather than by
borrowing it. Therefore, the <code>RwLock</code> must be wrapped in an <code>Arc</code> to
call this method, and the guard will live for the <code>'static</code> lifetime,
as it keeps the <code>RwLock</code> alive by holding an <code>Arc</code>.</p>
<h5 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::sync::Arc</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::RwLock</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>() {
<span class="kw">let</span> <span class="ident">rw</span> <span class="op">=</span> <span class="ident">Arc::new</span>(<span class="ident">RwLock::new</span>(<span class="number">1</span>));
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">Arc::clone</span>(<span class="kw-2">&amp;</span><span class="ident">rw</span>).<span class="ident">read_owned</span>().<span class="kw">await</span>;
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">v</span>, <span class="number">1</span>);
<span class="macro">assert!</span>(<span class="ident">rw</span>.<span class="ident">try_write_owned</span>().<span class="ident">is_err</span>());
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get_mut" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#1049-1054" title="goto source code">[src]</a></div><a href="#method.get_mut" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.get_mut" class="fnname">get_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>Returns a mutable reference to the underlying data.</p>
<p>Since this call borrows the <code>RwLock</code> mutably, no actual locking needs to
take place – the mutable borrow statically guarantees no locks exist.</p>
<h5 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::RwLock</span>;
<span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">lock</span> <span class="op">=</span> <span class="ident">RwLock::new</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="ident">lock</span>.<span class="ident">get_mut</span>();
<span class="kw-2">*</span><span class="ident">n</span> <span class="op">=</span> <span class="number">2</span>;
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_inner" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#1057-1062" title="goto source code">[src]</a></div><a href="#method.into_inner" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.into_inner" class="fnname">into_inner</a>(self) -&gt; 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></h4></div></summary><div class="docblock"><p>Consumes the lock, returning the underlying data.</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-Debug" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#89" title="goto source code">[src]</a></div><a href="#impl-Debug" class="anchor"></a><h3 class="code-header in-band">impl&lt;T:&nbsp;<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> + ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <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.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt;</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/sync/rwlock.rs.html#89" 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-Default" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#1071-1078" title="goto source code">[src]</a></div><a href="#impl-Default" class="anchor"></a><h3 class="code-header in-band">impl&lt;T:&nbsp;?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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/default/trait.Default.html" title="trait core::default::Default">Default</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.default" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#1075-1077" title="goto source code">[src]</a></div><a href="#method.default" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html#tymethod.default" class="fnname">default</a>() -&gt; Self</h4></div></summary><div class='docblock'><p>Returns the “default value” for a type. <a href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html#tymethod.default">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="../../src/tokio/sync/rwlock.rs.html#1065-1069" 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 <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt;</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="../../src/tokio/sync/rwlock.rs.html#1066-1068" title="goto source code">[src]</a></div><a href="#method.from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(s: T) -&gt; Self</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><div id="impl-Send" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#151" title="goto source code">[src]</a></div><a href="#impl-Send" 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/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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> + <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,&nbsp;</span></h3></div><div id="impl-Sync" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/tokio/sync/rwlock.rs.html#152" title="goto source code">[src]</a></div><a href="#impl-Sync" 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/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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> + <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,&nbsp;</span></h3></div></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&lt;T&gt; !<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.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt;</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&lt;T:&nbsp;?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <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.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,&nbsp;</span></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&lt;T:&nbsp;?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>&gt; <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.RwLock.html" title="struct tokio::sync::RwLock">RwLock</a>&lt;T&gt; <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/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a>,&nbsp;</span></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%3C!%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#566-570" title="goto source code">[src]</a></div><a href="#impl-From%3C!%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;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.never.html">!</a>&gt; for T</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.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#567" title="goto source code">[src]</a></div><a href="#method.from-1" 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: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.never.html">!</a>) -&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-From%3CT%3E-1" 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-1" 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-2" 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-2" 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-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.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" 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" 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" 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.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