mitchellhansen
/
Trac3r-rust
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'da836f318e'
${ noResults }
Trac3r-rust/doc/crossbeam/epoch/struct.Guard.html

279 lines
58 KiB
Raw Normal View History Unescape

add doc
5 years ago
<!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="API documentation for the Rust `Guard` struct in crate `crossbeam`."><meta name="keywords" content="rust, rustlang, rust-lang, Guard"><title>crossbeam::epoch::Guard - Rust</title><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="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="shortcut icon" href="../../favicon.ico"><style type="text/css">#crate-search{background-image:url("../../down-arrow.svg");}</style></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">&#9776;</div><a href='../../crossbeam/index.html'><div class='logo-container'><img src='../../rust-logo.png' alt='logo'></div></a><p class='location'>Struct Guard</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.collector">collector</a><a href="#method.defer">defer</a><a href="#method.defer_destroy">defer_destroy</a><a href="#method.defer_unchecked">defer_unchecked</a><a href="#method.flush">flush</a><a href="#method.repin">repin</a><a href="#method.repin_after">repin_after</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Debug">Debug</a><a href="#impl-Drop">Drop</a></div><a class="sidebar-title" href="#synthetic-implementations">Auto Trait Implementations</a><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><a class="sidebar-title" href="#blanket-implementations">Blanket Implementations</a><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><p class='location'><a href='../index.html'>crossbeam</a>::<wbr><a href='index.html'>epoch</a></p><script>window.sidebarCurrent = {name: 'Guard', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form js-only"><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><a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><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/crossbeam_epoch/guard.rs.html#68-70' title='goto source code'>[src]</a></span><span class='in-band'>Struct <a href='../index.html'>crossbeam</a>::<wbr><a href='index.html'>epoch</a>::<wbr><a class="struct" href=''>Guard</a></span></h1><div cla
<h1 id="pinning" class="section-header"><a href="#pinning">Pinning</a></h1>
<p>The current thread is pinned by calling <a href="fn.pin.html"><code>pin</code></a>, which returns a new guard:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span> <span class="kw">as</span> <span class="ident">epoch</span>;
<span class="comment">// It is often convenient to prefix a call to `pin` with a `&amp;` in order to create a reference.</span>
<span class="comment">// This is not really necessary, but makes passing references to the guard a bit easier.</span>
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();</pre></div>
<p>When a guard gets dropped, the current thread is automatically unpinned.</p>
<h1 id="pointers-on-the-stack" class="section-header"><a href="#pointers-on-the-stack">Pointers on the stack</a></h1>
<p>Having a guard allows us to create pointers on the stack to heap-allocated objects.
For example:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span>::{<span class="self">self</span> <span class="kw">as</span> <span class="ident">epoch</span>, <span class="ident">Atomic</span>, <span class="ident">Owned</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>;
<span class="comment">// Create a heap-allocated number.</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Atomic</span>::<span class="ident">new</span>(<span class="number">777</span>);
<span class="comment">// Pin the current thread.</span>
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="comment">// Load the heap-allocated object and create pointer `p` on the stack.</span>
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">load</span>(<span class="ident">SeqCst</span>, <span class="ident">guard</span>);
<span class="comment">// Dereference the pointer and print the value:</span>
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">num</span>) <span class="op">=</span> <span class="kw">unsafe</span> { <span class="ident">p</span>.<span class="ident">as_ref</span>() } {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;The number is {}.&quot;</span>, <span class="ident">num</span>);
}</pre></div>
<h1 id="multiple-guards" class="section-header"><a href="#multiple-guards">Multiple guards</a></h1>
<p>Pinning is reentrant and it is perfectly legal to create multiple guards. In that case, the
thread will actually be pinned only when the first guard is created and unpinned when the last
one is dropped:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span> <span class="kw">as</span> <span class="ident">epoch</span>;
<span class="kw">let</span> <span class="ident">guard1</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="kw">let</span> <span class="ident">guard2</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">epoch</span>::<span class="ident">is_pinned</span>());
<span class="ident">drop</span>(<span class="ident">guard1</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">epoch</span>::<span class="ident">is_pinned</span>());
<span class="ident">drop</span>(<span class="ident">guard2</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">epoch</span>::<span class="ident">is_pinned</span>());</pre></div>
</div><h2 id='methods' class='small-section-header'>Methods<a href='#methods' class='anchor'></a></h2><h3 id='impl' class='impl'><code class='in-band'>impl <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl' class='anchor'></a><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#72-415' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.defer' class="method"><code id='defer.v'>pub fn <a href='#method.defer' class='fnname'>defer</a>&lt;F, R&gt;(&amp;self, f: F) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -&gt; R + <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + 'static,&nbsp;</span></code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#90-98' title='goto source code'>[src]</a></h4><div class='docblock'><p>Stores a function so that it can be executed at some point after all currently pinned
threads get unpinned.</p>
<p>This method first stores <code>f</code> into the thread-local (or handle-local) cache. If this cache
becomes full, some functions are moved into the global cache. At the same time, some
functions from both local and global caches may get executed in order to incrementally
clean up the caches as they fill up.</p>
<p>There is no guarantee when exactly <code>f</code> will be executed. The only guarantee is that it
won't be executed until all currently pinned threads get unpinned. In theory, <code>f</code> might
never run, but the epoch-based garbage collection will make an effort to execute it
reasonably soon.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, the function will simply be
executed immediately.</p>
</div><h4 id='method.defer_unchecked' class="method"><code id='defer_unchecked.v'>pub unsafe fn <a href='#method.defer_unchecked' class='fnname'>defer_unchecked</a>&lt;F, R&gt;(&amp;self, f: F) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -&gt; R,&nbsp;</span></code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#190-197' title='goto source code'>[src]</a></h4><div class='docblock'><p>Stores a function so that it can be executed at some point after all currently pinned
threads get unpinned.</p>
<p>This method first stores <code>f</code> into the thread-local (or handle-local) cache. If this cache
becomes full, some functions are moved into the global cache. At the same time, some
functions from both local and global caches may get executed in order to incrementally
clean up the caches as they fill up.</p>
<p>There is no guarantee when exactly <code>f</code> will be executed. The only guarantee is that it
won't be executed until all currently pinned threads get unpinned. In theory, <code>f</code> might
never run, but the epoch-based garbage collection will make an effort to execute it
reasonably soon.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, the function will simply be
executed immediately.</p>
<h1 id="safety" class="section-header"><a href="#safety">Safety</a></h1>
<p>The given function must not hold reference onto the stack. It is highly recommended that
the passed function is <strong>always</strong> marked with <code>move</code> in order to prevent accidental
borrows.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span> <span class="kw">as</span> <span class="ident">epoch</span>;
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="kw">let</span> <span class="ident">message</span> <span class="op">=</span> <span class="string">&quot;Hello!&quot;</span>;
<span class="kw">unsafe</span> {
<span class="comment">// ALWAYS use `move` when sending a closure into `defer_unchecked`.</span>
<span class="ident">guard</span>.<span class="ident">defer_unchecked</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{}&quot;</span>, <span class="ident">message</span>);
});
}</pre></div>
<p>Apart from that, keep in mind that another thread may execute <code>f</code>, so anything accessed by
the closure must be <code>Send</code>.</p>
<p>We intentionally didn't require <code>F: Send</code>, because Rust's type systems usually cannot prove
<code>F: Send</code> for typical use cases. For example, consider the following code snippet, which
exemplifies the typical use case of deferring the deallocation of a shared reference:</p>
<div class='information'><div class='tooltip ignore'>ⓘ<span class='tooltiptext'>This example is not tested</span></div></div><div class="example-wrap"><pre class="rust rust-example-rendered ignore">
<span class="kw">let</span> <span class="ident">shared</span> <span class="op">=</span> <span class="ident">Owned</span>::<span class="ident">new</span>(<span class="number">7i32</span>).<span class="ident">into_shared</span>(<span class="ident">guard</span>);
<span class="ident">guard</span>.<span class="ident">defer_unchecked</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">shared</span>.<span class="ident">into_owned</span>()); <span class="comment">// `Shared` is not `Send`!</span></pre></div>
<p>While <code>Shared</code> is not <code>Send</code>, it's safe for another thread to call the deferred function,
because it's called only after the grace period and <code>shared</code> is no longer shared with other
threads. But we don't expect type systems to prove this.</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<p>When a heap-allocated object in a data structure becomes unreachable, it has to be
deallocated. However, the current thread and other threads may be still holding references
on the stack to that same object. Therefore it cannot be deallocated before those references
get dropped. This method can defer deallocation until all those threads get unpinned and
consequently drop all their references on the stack.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span>::{<span class="self">self</span> <span class="kw">as</span> <span class="ident">epoch</span>, <span class="ident">Atomic</span>, <span class="ident">Owned</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Atomic</span>::<span class="ident">new</span>(<span class="string">&quot;foo&quot;</span>);
<span class="comment">// Now suppose that `a` is shared among multiple threads and concurrently</span>
<span class="comment">// accessed and modified...</span>
<span class="comment">// Pin the current thread.</span>
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="comment">// Steal the object currently stored in `a` and swap it with another one.</span>
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">swap</span>(<span class="ident">Owned</span>::<span class="ident">new</span>(<span class="string">&quot;bar&quot;</span>).<span class="ident">into_shared</span>(<span class="ident">guard</span>), <span class="ident">SeqCst</span>, <span class="ident">guard</span>);
<span class="kw">if</span> <span class="op">!</span><span class="ident">p</span>.<span class="ident">is_null</span>() {
<span class="comment">// The object `p` is pointing to is now unreachable.</span>
<span class="comment">// Defer its deallocation until all currently pinned threads get unpinned.</span>
<span class="kw">unsafe</span> {
<span class="comment">// ALWAYS use `move` when sending a closure into `defer_unchecked`.</span>
<span class="ident">guard</span>.<span class="ident">defer_unchecked</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{} is now being deallocated.&quot;</span>, <span class="ident">p</span>.<span class="ident">deref</span>());
<span class="comment">// Now we have unique access to the object pointed to by `p` and can turn it</span>
<span class="comment">// into an `Owned`. Dropping the `Owned` will deallocate the object.</span>
<span class="ident">drop</span>(<span class="ident">p</span>.<span class="ident">into_owned</span>());
});
}
}</pre></div>
</div><h4 id='method.defer_destroy' class="method"><code id='defer_destroy.v'>pub unsafe fn <a href='#method.defer_destroy' class='fnname'>defer_destroy</a>&lt;T&gt;(&amp;self, ptr: <a class="struct" href="../../crossbeam/epoch/struct.Shared.html" title="struct crossbeam::epoch::Shared">Shared</a>&lt;T&gt;)</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#269-271' title='goto source code'>[src]</a></h4><div class='docblock'><p>Stores a destructor for an object so that it can be deallocated and dropped at some point
after all currently pinned threads get unpinned.</p>
<p>This method first stores the destructor into the thread-local (or handle-local) cache. If
this cache becomes full, some destructors are moved into the global cache. At the same
time, some destructors from both local and global caches may get executed in order to
incrementally clean up the caches as they fill up.</p>
<p>There is no guarantee when exactly the destructor will be executed. The only guarantee is
that it won't be executed until all currently pinned threads get unpinned. In theory, the
destructor might never run, but the epoch-based garbage collection will make an effort to
execute it reasonably soon.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, the destructor will simply be
executed immediately.</p>
<h1 id="safety-1" class="section-header"><a href="#safety-1">Safety</a></h1>
<p>The object must not be reachable by other threads anymore, otherwise it might be still in
use when the destructor runs.</p>
<p>Apart from that, keep in mind that another thread may execute the destructor, so the object
must be sendable to other threads.</p>
<p>We intentionally didn't require <code>T: Send</code>, because Rust's type systems usually cannot prove
<code>T: Send</code> for typical use cases. For example, consider the following code snippet, which
exemplifies the typical use case of deferring the deallocation of a shared reference:</p>
<div class='information'><div class='tooltip ignore'>ⓘ<span class='tooltiptext'>This example is not tested</span></div></div><div class="example-wrap"><pre class="rust rust-example-rendered ignore">
<span class="kw">let</span> <span class="ident">shared</span> <span class="op">=</span> <span class="ident">Owned</span>::<span class="ident">new</span>(<span class="number">7i32</span>).<span class="ident">into_shared</span>(<span class="ident">guard</span>);
<span class="ident">guard</span>.<span class="ident">defer_destroy</span>(<span class="ident">shared</span>); <span class="comment">// `Shared` is not `Send`!</span></pre></div>
<p>While <code>Shared</code> is not <code>Send</code>, it's safe for another thread to call the destructor, because
it's called only after the grace period and <code>shared</code> is no longer shared with other
threads. But we don't expect type systems to prove this.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<p>When a heap-allocated object in a data structure becomes unreachable, it has to be
deallocated. However, the current thread and other threads may be still holding references
on the stack to that same object. Therefore it cannot be deallocated before those references
get dropped. This method can defer deallocation until all those threads get unpinned and
consequently drop all their references on the stack.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span>::{<span class="self">self</span> <span class="kw">as</span> <span class="ident">epoch</span>, <span class="ident">Atomic</span>, <span class="ident">Owned</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Atomic</span>::<span class="ident">new</span>(<span class="string">&quot;foo&quot;</span>);
<span class="comment">// Now suppose that `a` is shared among multiple threads and concurrently</span>
<span class="comment">// accessed and modified...</span>
<span class="comment">// Pin the current thread.</span>
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="comment">// Steal the object currently stored in `a` and swap it with another one.</span>
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">swap</span>(<span class="ident">Owned</span>::<span class="ident">new</span>(<span class="string">&quot;bar&quot;</span>).<span class="ident">into_shared</span>(<span class="ident">guard</span>), <span class="ident">SeqCst</span>, <span class="ident">guard</span>);
<span class="kw">if</span> <span class="op">!</span><span class="ident">p</span>.<span class="ident">is_null</span>() {
<span class="comment">// The object `p` is pointing to is now unreachable.</span>
<span class="comment">// Defer its deallocation until all currently pinned threads get unpinned.</span>
<span class="kw">unsafe</span> {
<span class="ident">guard</span>.<span class="ident">defer_destroy</span>(<span class="ident">p</span>);
}
}</pre></div>
</div><h4 id='method.flush' class="method"><code id='flush.v'>pub fn <a href='#method.flush' class='fnname'>flush</a>(&amp;self)</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#297-301' title='goto source code'>[src]</a></h4><div class='docblock'><p>Clears up the thread-local cache of deferred functions by executing them or moving into the
global cache.</p>
<p>Call this method after deferring execution of a function if you want to get it executed as
soon as possible. Flushing will make sure it is residing in in the global cache, so that
any thread has a chance of taking the function and executing it.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, it is a no-op (nothing happens).</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span> <span class="kw">as</span> <span class="ident">epoch</span>;
<span class="kw">let</span> <span class="ident">guard</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="kw">unsafe</span> {
<span class="ident">guard</span>.<span class="ident">defer</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;This better be printed as soon as possible!&quot;</span>);
});
}
<span class="ident">guard</span>.<span class="ident">flush</span>();</pre></div>
</div><h4 id='method.repin' class="method"><code id='repin.v'>pub fn <a href='#method.repin' class='fnname'>repin</a>(&amp;mut self)</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#334-338' title='goto source code'>[src]</a></h4><div class='docblock'><p>Unpins and then immediately re-pins the thread.</p>
<p>This method is useful when you don't want delay the advancement of the global epoch by
holding an old epoch. For safety, you should not maintain any guard-based reference across
the call (the latter is enforced by <code>&amp;mut self</code>). The thread will only be repinned if this
is the only active guard for the current thread.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, then the call will be just no-op.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span>::{<span class="self">self</span> <span class="kw">as</span> <span class="ident">epoch</span>, <span class="ident">Atomic</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">thread</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::<span class="ident">Duration</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Atomic</span>::<span class="ident">new</span>(<span class="number">777</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">guard</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
{
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">load</span>(<span class="ident">SeqCst</span>, <span class="kw-2">&amp;</span><span class="ident">guard</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw">unsafe</span> { <span class="ident">p</span>.<span class="ident">as_ref</span>() }, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">777</span>));
}
<span class="ident">guard</span>.<span class="ident">repin</span>();
{
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">load</span>(<span class="ident">SeqCst</span>, <span class="kw-2">&amp;</span><span class="ident">guard</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw">unsafe</span> { <span class="ident">p</span>.<span class="ident">as_ref</span>() }, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">777</span>));
}</pre></div>
</div><h4 id='method.repin_after' class="method"><code id='repin_after.v'>pub fn <a href='#method.repin_after' class='fnname'>repin_after</a>&lt;F, R&gt;(&amp;mut self, f: F) -&gt; R <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -&gt; R,&nbsp;</span></code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#372-392' title='goto source code'>[src]</a></h4><div class='docblock'><p>Temporarily unpins the thread, executes the given function and then re-pins the thread.</p>
<p>This method is useful when you need to perform a long-running operation (e.g. sleeping)
and don't need to maintain any guard-based reference across the call (the latter is enforced
by <code>&amp;mut self</code>). The thread will only be unpinned if this is the only active guard for the
current thread.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, then the passed function is called
directly without unpinning the thread.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span>::{<span class="self">self</span> <span class="kw">as</span> <span class="ident">epoch</span>, <span class="ident">Atomic</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::<span class="ident">Ordering</span>::<span class="ident">SeqCst</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">thread</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">time</span>::<span class="ident">Duration</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">Atomic</span>::<span class="ident">new</span>(<span class="number">777</span>);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">guard</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
{
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">load</span>(<span class="ident">SeqCst</span>, <span class="kw-2">&amp;</span><span class="ident">guard</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw">unsafe</span> { <span class="ident">p</span>.<span class="ident">as_ref</span>() }, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">777</span>));
}
<span class="ident">guard</span>.<span class="ident">repin_after</span>(<span class="op">|</span><span class="op">|</span> <span class="ident">thread</span>::<span class="ident">sleep</span>(<span class="ident">Duration</span>::<span class="ident">from_millis</span>(<span class="number">50</span>)));
{
<span class="kw">let</span> <span class="ident">p</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">load</span>(<span class="ident">SeqCst</span>, <span class="kw-2">&amp;</span><span class="ident">guard</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw">unsafe</span> { <span class="ident">p</span>.<span class="ident">as_ref</span>() }, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">777</span>));
}</pre></div>
</div><h4 id='method.collector' class="method"><code id='collector.v'>pub fn <a href='#method.collector' class='fnname'>collector</a>(&amp;self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;&amp;<a class="struct" href="../../crossbeam/epoch/struct.Collector.html" title="struct crossbeam::epoch::Collector">Collector</a>&gt;</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#412-414' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the <code>Collector</code> associated with this guard.</p>
<p>This method is useful when you need to ensure that all guards used with
a data structure come from the same collector.</p>
<p>If this method is called from an <a href="fn.unprotected.html"><code>unprotected</code></a> guard, then <code>None</code> is returned.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">crossbeam_epoch</span> <span class="kw">as</span> <span class="ident">epoch</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">guard1</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">guard2</span> <span class="op">=</span> <span class="ident">epoch</span>::<span class="ident">pin</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">guard1</span>.<span class="ident">collector</span>() <span class="op">=</span><span class="op">=</span> <span class="ident">guard2</span>.<span class="ident">collector</span>());</pre></div>
</div></div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-Debug' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-Debug' class='anchor'></a><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#426-430' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method hidden"><code id='fmt.v'>fn <a href='https://doc.rust-lang.org/nightly/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/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html" title="struct core::fmt::Error">Error</a>&gt;</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#427-429' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-Drop' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html" title="trait core::ops::drop::Drop">Drop</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-Drop' class='anchor'></a><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#417-424' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.drop' class="method hidden"><code id='drop.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&amp;mut self)</code><a class='srclink' href='../../src/crossbeam_epoch/guard.rs.html#419-423' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Executes the destructor for this type. <a href="https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop">Read more</a></p>
</div></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'><h3 id='impl-Send' class='impl'><code class='in-band'>impl !<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-Send' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Unpin' class='impl'><code class='in-band'>impl <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-Unpin' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><code class='in-band'>impl !<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-Sync' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-UnwindSafe' class='impl'><code class='in-band'>impl !<a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-UnwindSafe' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-RefUnwindSafe' class='impl'><code class='in-band'>impl !<a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="../../crossbeam/epoch/struct.Guard.html" title="struct crossbeam::epoch::Guard">Guard</a></code><a href='#impl-RefUnwindSafe' class='anchor'></a></h3><div class='impl-items'></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'><h3 id='impl-Into%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-Into%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#544-549' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -&gt; U</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#546-548' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</code><a href='#impl-From%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#553-555' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#554' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-TryFrom%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryFrom%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#572-578' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='https://doc.rust-lang.org/nightly/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/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#575-577' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-TryInto%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryInto%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#560-567' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#564-566' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-BorrowMut%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-BorrowMut%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#218-220' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W</h3><code class="content"><span class="where fmt-newline">impl&lt;'_, W&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline">impl&lt;'_, R&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>R <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline">impl&lt;'_, I&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>I <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = &lt;I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a>&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::traits::iterator::Iterator::Item">Item</a>;</span><span class="where fmt-newline">impl&lt;'_, F&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/future/future/trait.Future.html" title="trait core::future::future::Future">Future</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>F <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://d
</div></div><h3 id='impl-Borrow%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Borrow%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#213-215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W</h3><code class="content"><span class="where fmt-newline">impl&lt;'_, W&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>W <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;W: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Write.html" title="trait std::io::Write">Write</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline">impl&lt;'_, R&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>R <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="https://doc.rust-lang.org/nightly/std/io/trait.Read.html" title="trait std::io::Read">Read</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline">impl&lt;'_, I&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>I <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = &lt;I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a>&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::traits::iterator::Iterator::Item">Item</a>;</span><span class="where fmt-newline">impl&lt;'_, F&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/future/future/trait.Future.html" title="trait core::future::future::Future">Future</a> for <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'_ mut </a>F <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/ni
</div></div><h3 id='impl-Any' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#100-102' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='https://doc.rust-lang.org/nightly/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/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>&#9166;</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g., <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g., <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g., <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../../";window.currentCrate = "crossbeam";</script><script src="../../aliases.js"></script><script src="../../main.js"></script><script defer src="../../search-index.js"></script></body></html>