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/crossbeam_utils/atomic/struct.AtomicCell.html

1004 lines
212 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

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

<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="A thread-safe mutable memory location."><meta name="keywords" content="rust, rustlang, rust-lang, AtomicCell"><title>AtomicCell in crossbeam_utils::atomic - 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="../../crossbeam_utils/index.html"><div class="logo-container"><img class="rust-logo" src="../../rust-logo.png" alt="logo"></div>
</a><h2 class="location">Struct AtomicCell</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.as_ptr">as_ptr</a><a href="#method.compare_and_swap">compare_and_swap</a><a href="#method.compare_exchange">compare_exchange</a><a href="#method.fetch_add">fetch_add</a><a href="#method.fetch_add-1">fetch_add</a><a href="#method.fetch_add-10">fetch_add</a><a href="#method.fetch_add-11">fetch_add</a><a href="#method.fetch_add-2">fetch_add</a><a href="#method.fetch_add-3">fetch_add</a><a href="#method.fetch_add-4">fetch_add</a><a href="#method.fetch_add-5">fetch_add</a><a href="#method.fetch_add-6">fetch_add</a><a href="#method.fetch_add-7">fetch_add</a><a href="#method.fetch_add-8">fetch_add</a><a href="#method.fetch_add-9">fetch_add</a><a href="#method.fetch_and">fetch_and</a><a href="#method.fetch_and-1">fetch_and</a><a href="#method.fetch_and-10">fetch_and</a><a href="#method.fetch_and-11">fetch_and</a><a href="#method.fetch_and-12">fetch_and</a><a href="#method.fetch_and-2">fetch_and</a><a href="#method.fetch_and-3">fetch_and</a><a href="#method.fetch_and-4">fetch_and</a><a href="#method.fetch_and-5">fetch_and</a><a href="#method.fetch_and-6">fetch_and</a><a href="#method.fetch_and-7">fetch_and</a><a href="#method.fetch_and-8">fetch_and</a><a href="#method.fetch_and-9">fetch_and</a><a href="#method.fetch_max">fetch_max</a><a href="#method.fetch_max-1">fetch_max</a><a href="#method.fetch_max-10">fetch_max</a><a href="#method.fetch_max-11">fetch_max</a><a href="#method.fetch_max-2">fetch_max</a><a href="#method.fetch_max-3">fetch_max</a><a href="#method.fetch_max-4">fetch_max</a><a href="#method.fetch_max-5">fetch_max</a><a href="#method.fetch_max-6">fetch_max</a><a href="#method.fetch_max-7">fetch_max</a><a href="#method.fetch_max-8">fetch_max</a><a href="#method.fetch_max-9">fetch_max</a><a href="#method.fetch_min">fetch_min</a><a href="#method.fetch_min-1">fetch_min</a><a href="#method.fetch_min-10">fetch_min</a><a href="#method.fetch_min-11">fetch_min</a><a href="#method.fetch_min-2">fetch_min</a><a href="#method.fetch_min-3">fetch_min</a><a href="#method.fetch_min-4">fetch_min</a><a href="#method.fetch_min-5">fetch_min</a><a href="#method.fetch_min-6">fetch_min</a><a href="#method.fetch_min-7">fetch_min</a><a href="#method.fetch_min-8">fetch_min</a><a href="#method.fetch_min-9">fetch_min</a><a href="#method.fetch_nand">fetch_nand</a><a href="#method.fetch_nand-1">fetch_nand</a><a href="#method.fetch_nand-10">fetch_nand</a><a href="#method.fetch_nand-11">fetch_nand</a><a href="#method.fetch_nand-12">fetch_nand</a><a href="#method.fetch_nand-2">fetch_nand</a><a href="#method.fetch_nand-3">fetch_nand</a><a href="#method.fetch_nand-4">fetch_nand</a><a href="#method.fetch_nand-5">fetch_nand</a><a href="#method.fetch_nand-6">fetch_nand</a><a href="#method.fetch_nand-7">fetch_nand</a><a href="#method.fetch_nand-8">fetch_nand</a><a href="#method.fetch_nand-9">fetch_nand</a><a href="#method.fetch_or">fetch_or</a><a href="#method.fetch_or-1">fetch_or</a><a href="#method.fetch_or-10">fetch_or</a><a href="#method.fetch_or-11">fetch_or</a><a href="#method.fetch_or-12">fetch_or</a><a href="#method.fetch_or-2">fetch_or</a><a href="#method.fetch_or-3">fetch_or</a><a href="#method.fetch_or-4">fetch_or</a><a href="#method.fetch_or-5">fetch_or</a><a href="#method.fetch_or-6">fetch_or</a><a href="#method.fetch_or-7">fetch_or</a><a href="#method.fetch_or-8">fetch_or</a><a href="#method.fetch_or-9">fetch_or</a><a href="#method.fetch_sub">fetch_sub</a><a href="#method.fetch_sub-1">fetch_sub</a><a href="#method.fetch_sub-10">fetch_sub</a><a href="#method.fetch_sub-11">fetch_sub</a><a href="#method.fetch_sub-2">fetch_sub</a><a href="#method.fetch_sub-3">fetch_sub</a><a href="#method.fetch_sub-4">fetch_sub</a><a href="#method.fetch_sub-5">fetch_sub</a><a href="#method.fetch_sub-6">fetch_sub</a><a href="#method.fetch_sub-7">fetch_sub</a><a href="#method.fetch_sub-8">fetch_sub</a><a href="#method.fetch_sub-9">fetch_sub</a><a href="#method.fetch_update">fetch_update</a><a href="#method.fetch_xor">fetch_xor</a><a href="#method.fetch_xor-1">fetch_xor</a><a href="#method.fetch_xor-10">fetch_xor</a><a href="#method.fetch_xor-11">fetch_xor</a><a href="#method.fetch_xor-12">fetch_xor</a><a href="#method.fetch_xor-2">fetch_xor</a><a href="#method.fetch_xor-3">fetch_xor</a><a href="#method.fetch_xor-4">fetch_xor</a><a href="#method.fetch_xor-5">fetch_xor</a><a href="#method.fetch_xor-6">fetch_xor</a><a href="#method.fetch_xor-7">fetch_xor</a><a href="#method.fetch_xor-8">fetch_xor</a><a href="#method.fetch_xor-9">fetch_xor</a><a href="#method.into_inner">into_inner</a><a href="#method.is_lock_free">is_lock_free</a><a href="#method.load">load</a><a href="#method.new">new</a><a href="#method.store">store</a><a href="#method.swap">swap</a><a href="#method.take">take</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-RefUnwindSafe">RefUnwindSafe</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a><a href="#impl-UnwindSafe">UnwindSafe</a></div><h3 class="sidebar-title"><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><div class="sidebar-links"><a href="#impl-Unpin">Unpin</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">crossbeam_utils</a>::<wbr><a href="index.html">atomic</a></h2><div id="sidebar-vars" data-name="AtomicCell" 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="../../crossbeam_utils/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">crossbeam_utils</a>::<wbr><a href="index.html">atomic</a>::<wbr><a class="struct" href="#">AtomicCell</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/crossbeam_utils/atomic/atomic_cell.rs.html#33-40" title="goto source code">[src]</a></span></h1><div class="docblock item-decl"><pre class="rust struct"><code><div class="code-attribute">#[repr(transparent)]</div>pub struct AtomicCell&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>A thread-safe mutable memory location.</p>
<p>This type is equivalent to <a href="https://doc.rust-lang.org/1.59.0/core/cell/struct.Cell.html"><code>Cell</code></a>, except it can also be shared among multiple threads.</p>
<p>Operations on <code>AtomicCell</code>s use atomic instructions whenever possible, and synchronize using
global locks otherwise. You can call <a href="struct.AtomicCell.html#method.is_lock_free"><code>AtomicCell::&lt;T&gt;::is_lock_free()</code></a> to check whether
atomic instructions or locks will be used.</p>
<p>Atomic loads use the <a href="https://doc.rust-lang.org/1.59.0/core/sync/atomic/enum.Ordering.html#variant.Acquire"><code>Acquire</code></a> ordering and atomic stores use the <a href="https://doc.rust-lang.org/1.59.0/core/sync/atomic/enum.Ordering.html#variant.Release"><code>Release</code></a> ordering.</p>
</div></details><h2 id="implementations" class="small-section-header">Implementations<a href="#implementations" class="anchor"></a></h2><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#50-153" title="goto source code">[src]</a></div><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</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/crossbeam_utils/atomic/atomic_cell.rs.html#60-64" title="goto source code">[src]</a></div><a href="#method.new" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.new" class="fnname">new</a>(val: T) -&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h4></div></summary><div class="docblock"><p>Creates a new atomic cell initialized with <code>val</code>.</p>
<h5 id="examples" class="section-header"><a href="#examples">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</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/crossbeam_utils/atomic/atomic_cell.rs.html#78-80" 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</h4></div></summary><div class="docblock"><p>Consumes the atomic and returns the contained value.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</span>);
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">into_inner</span>();
<span class="macro">assert_eq!</span>(<span class="ident">v</span>, <span class="number">7</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_lock_free" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#110-112" title="goto source code">[src]</a></div><a href="#method.is_lock_free" class="anchor"></a><h4 class="code-header">pub const fn <a href="#method.is_lock_free" class="fnname">is_lock_free</a>() -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Returns <code>true</code> if operations on values of this type are lock-free.</p>
<p>If the compiler or the platform doesn’t support the necessary atomic instructions,
<code>AtomicCell&lt;T&gt;</code> will use global locks for every potentially concurrent atomic operation.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="comment">// This type is internally represented as `AtomicUsize` so we can just use atomic</span>
<span class="comment">// operations provided by it.</span>
<span class="macro">assert_eq!</span>(<span class="ident">AtomicCell</span>::<span class="op">&lt;</span><span class="ident">usize</span><span class="op">&gt;</span><span class="ident">::is_lock_free</span>(), <span class="bool-val">true</span>);
<span class="comment">// A wrapper struct around `isize`.</span>
<span class="kw">struct</span> <span class="ident">Foo</span> {
<span class="ident">bar</span>: <span class="ident">isize</span>,
}
<span class="comment">// `AtomicCell&lt;Foo&gt;` will be internally represented as `AtomicIsize`.</span>
<span class="macro">assert_eq!</span>(<span class="ident">AtomicCell</span>::<span class="op">&lt;</span><span class="ident">Foo</span><span class="op">&gt;</span><span class="ident">::is_lock_free</span>(), <span class="bool-val">true</span>);
<span class="comment">// Operations on zero-sized types are always lock-free.</span>
<span class="macro">assert_eq!</span>(<span class="ident">AtomicCell</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span><span class="ident">::is_lock_free</span>(), <span class="bool-val">true</span>);
<span class="comment">// Very large types cannot be represented as any of the standard atomic types, so atomic</span>
<span class="comment">// operations on them will have to use global locks for synchronization.</span>
<span class="macro">assert_eq!</span>(<span class="ident">AtomicCell</span>::<span class="op">&lt;</span>[<span class="ident">u8</span>; <span class="number">1000</span>]<span class="op">&gt;</span><span class="ident">::is_lock_free</span>(), <span class="bool-val">false</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.store" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#127-135" title="goto source code">[src]</a></div><a href="#method.store" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.store" class="fnname">store</a>(&amp;self, val: T)</h4></div></summary><div class="docblock"><p>Stores <code>val</code> into the atomic cell.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">7</span>);
<span class="ident">a</span>.<span class="ident">store</span>(<span class="number">8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">8</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.swap" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#150-152" title="goto source code">[src]</a></div><a href="#method.swap" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.swap" class="fnname">swap</a>(&amp;self, val: T) -&gt; T</h4></div></summary><div class="docblock"><p>Stores <code>val</code> into the atomic cell and returns the previous value.</p>
<h5 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">swap</span>(<span class="number">8</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">8</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-1" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#155-171" title="goto source code">[src]</a></div><a href="#impl-1" 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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ptr" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#168-170" title="goto source code">[src]</a></div><a href="#method.as_ptr" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.as_ptr" class="fnname">as_ptr</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.pointer.html">*mut T</a></h4></div></summary><div class="docblock"><p>Returns a raw pointer to the underlying data in this atomic cell.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">ptr</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">as_ptr</span>();</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-2" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#173-190" title="goto source code">[src]</a></div><a href="#impl-2" 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/default/trait.Default.html" title="trait core::default::Default">Default</a>&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.take" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#187-189" title="goto source code">[src]</a></div><a href="#method.take" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.take" class="fnname">take</a>(&amp;self) -&gt; T</h4></div></summary><div class="docblock"><p>Takes the value of the atomic cell, leaving <code>Default::default()</code> in its place.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">a</span>.<span class="ident">take</span>();
<span class="macro">assert_eq!</span>(<span class="ident">five</span>, <span class="number">5</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">into_inner</span>(), <span class="number">0</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-3" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#192-207" title="goto source code">[src]</a></div><a href="#impl-3" 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.Copy.html" title="trait core::marker::Copy">Copy</a>&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.load" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#204-206" title="goto source code">[src]</a></div><a href="#method.load" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.load" class="fnname">load</a>(&amp;self) -&gt; T</h4></div></summary><div class="docblock"><p>Loads a value from the atomic cell.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">7</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-4" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#209-293" title="goto source code">[src]</a></div><a href="#impl-4" 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.Copy.html" title="trait core::marker::Copy">Copy</a> + <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.compare_and_swap" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#231-236" title="goto source code">[src]</a></div><a href="#method.compare_and_swap" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.compare_and_swap" class="fnname">compare_and_swap</a>(&amp;self, current: T, new: T) -&gt; T</h4></div><div class="item-info"><div class="stab deprecated"><span class="emoji">👎</span> Deprecated: <p>Use <code>compare_exchange</code> instead</p>
</div></div></summary><div class="docblock"><p>If the current value equals <code>current</code>, stores <code>new</code> into the atomic cell.</p>
<p>The return value is always the previous value. If it is equal to <code>current</code>, then the value
was updated.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">compare_and_swap</span>(<span class="number">2</span>, <span class="number">3</span>), <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">compare_and_swap</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.compare_exchange" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#256-258" title="goto source code">[src]</a></div><a href="#method.compare_exchange" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.compare_exchange" class="fnname">compare_exchange</a>(&amp;self, current: T, new: T) -&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, T&gt;</h4></div></summary><div class="docblock"><p>If the current value equals <code>current</code>, stores <code>new</code> into the atomic cell.</p>
<p>The return value is a result indicating whether the new value was written and containing
the previous value. On success this value is guaranteed to be equal to <code>current</code>.</p>
<h5 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">compare_exchange</span>(<span class="number">2</span>, <span class="number">3</span>), <span class="prelude-val">Err</span>(<span class="number">1</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">compare_exchange</span>(<span class="number">1</span>, <span class="number">2</span>), <span class="prelude-val">Ok</span>(<span class="number">1</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_update" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#280-292" title="goto source code">[src]</a></div><a href="#method.fetch_update" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_update" class="fnname">fetch_update</a>&lt;F&gt;(&amp;self, f: F) -&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, T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(T) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;T&gt;,&nbsp;</span></h4></div></summary><div class="docblock"><p>Fetches the value, and applies a function to it that returns an optional
new value. Returns a <code>Result</code> of <code>Ok(previous_value)</code> if the function returned <code>Some(_)</code>, else
<code>Err(previous_value)</code>.</p>
<p>Note: This may call the function multiple times if the value has been changed from other threads in
the meantime, as long as the function returns <code>Some(_)</code>, but the function will have been applied
only once to the stored value.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_update</span>(<span class="op">|</span><span class="kw">_</span><span class="op">|</span> <span class="prelude-val">None</span>), <span class="prelude-val">Err</span>(<span class="number">7</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_update</span>(<span class="op">|</span><span class="ident">a</span><span class="op">|</span> <span class="prelude-val">Some</span>(<span class="ident">a</span> <span class="op">+</span> <span class="number">1</span>)), <span class="prelude-val">Ok</span>(<span class="number">7</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_update</span>(<span class="op">|</span><span class="ident">a</span><span class="op">|</span> <span class="prelude-val">Some</span>(<span class="ident">a</span> <span class="op">+</span> <span class="number">1</span>)), <span class="prelude-val">Ok</span>(<span class="number">8</span>));
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-5" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#impl-5" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_add" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_sub" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_and" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</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">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_nand" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_or" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_xor" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_max" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#692" title="goto source code">[src]</a></div><a href="#method.fetch_min" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u8.html">u8</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-6" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#impl-6" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_add-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-1" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_sub-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-1" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_and-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-1" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_nand-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-1" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_or-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-1" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-23" class="section-header"><a href="#examples-23">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_xor-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-1" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-24" class="section-header"><a href="#examples-24">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_max-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-1" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-25" class="section-header"><a href="#examples-25">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-1" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#693" title="goto source code">[src]</a></div><a href="#method.fetch_min-1" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-1" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i8.html">i8</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-26" class="section-header"><a href="#examples-26">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i8</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-7" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#impl-7" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_add-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-2" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-27" class="section-header"><a href="#examples-27">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_sub-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-2" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-28" class="section-header"><a href="#examples-28">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_and-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-2" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-29" class="section-header"><a href="#examples-29">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_nand-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-2" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-30" class="section-header"><a href="#examples-30">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_or-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-2" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-31" class="section-header"><a href="#examples-31">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_xor-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-2" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-32" class="section-header"><a href="#examples-32">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_max-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-2" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-33" class="section-header"><a href="#examples-33">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-2" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#694" title="goto source code">[src]</a></div><a href="#method.fetch_min-2" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-2" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u16.html">u16</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-34" class="section-header"><a href="#examples-34">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-8" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#impl-8" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_add-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-3" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-35" class="section-header"><a href="#examples-35">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_sub-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-3" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-36" class="section-header"><a href="#examples-36">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_and-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-3" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-37" class="section-header"><a href="#examples-37">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_nand-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-3" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-38" class="section-header"><a href="#examples-38">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_or-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-3" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-39" class="section-header"><a href="#examples-39">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_xor-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-3" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-40" class="section-header"><a href="#examples-40">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_max-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-3" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-41" class="section-header"><a href="#examples-41">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-3" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#695" title="goto source code">[src]</a></div><a href="#method.fetch_min-3" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-3" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i16.html">i16</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-42" class="section-header"><a href="#examples-42">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i16</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-9" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#impl-9" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_add-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-4" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-43" class="section-header"><a href="#examples-43">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_sub-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-4" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-44" class="section-header"><a href="#examples-44">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_and-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-4" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-45" class="section-header"><a href="#examples-45">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_nand-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-4" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-46" class="section-header"><a href="#examples-46">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_or-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-4" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-47" class="section-header"><a href="#examples-47">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_xor-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-4" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-48" class="section-header"><a href="#examples-48">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_max-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-4" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-49" class="section-header"><a href="#examples-49">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-4" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#696" title="goto source code">[src]</a></div><a href="#method.fetch_min-4" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-4" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u32.html">u32</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-50" class="section-header"><a href="#examples-50">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-10" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#impl-10" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_add-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-5" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-51" class="section-header"><a href="#examples-51">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_sub-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-5" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-52" class="section-header"><a href="#examples-52">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_and-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-5" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-53" class="section-header"><a href="#examples-53">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_nand-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-5" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-54" class="section-header"><a href="#examples-54">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_or-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-5" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-55" class="section-header"><a href="#examples-55">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_xor-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-5" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-56" class="section-header"><a href="#examples-56">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_max-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-5" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-57" class="section-header"><a href="#examples-57">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-5" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#697" title="goto source code">[src]</a></div><a href="#method.fetch_min-5" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-5" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i32.html">i32</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-58" class="section-header"><a href="#examples-58">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i32</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-11" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#impl-11" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_add-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-6" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-59" class="section-header"><a href="#examples-59">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_sub-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-6" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-60" class="section-header"><a href="#examples-60">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_and-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-6" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-61" class="section-header"><a href="#examples-61">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_nand-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-6" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-62" class="section-header"><a href="#examples-62">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_or-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-6" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-63" class="section-header"><a href="#examples-63">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_xor-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-6" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-64" class="section-header"><a href="#examples-64">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_max-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-6" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-65" class="section-header"><a href="#examples-65">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-6" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#699" title="goto source code">[src]</a></div><a href="#method.fetch_min-6" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-6" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u64.html">u64</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-66" class="section-header"><a href="#examples-66">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-12" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#impl-12" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_add-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-7" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-67" class="section-header"><a href="#examples-67">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_sub-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-7" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-68" class="section-header"><a href="#examples-68">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_and-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-7" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-69" class="section-header"><a href="#examples-69">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_nand-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-7" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-70" class="section-header"><a href="#examples-70">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_or-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-7" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-71" class="section-header"><a href="#examples-71">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_xor-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-7" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-72" class="section-header"><a href="#examples-72">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_max-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-7" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-73" class="section-header"><a href="#examples-73">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-7" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#701" title="goto source code">[src]</a></div><a href="#method.fetch_min-7" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-7" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i64.html">i64</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-74" class="section-header"><a href="#examples-74">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i64</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-13" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#impl-13" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_add-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-8" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-75" class="section-header"><a href="#examples-75">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_sub-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-8" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-76" class="section-header"><a href="#examples-76">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_and-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-8" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-77" class="section-header"><a href="#examples-77">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_nand-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-8" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-78" class="section-header"><a href="#examples-78">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_or-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-8" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-79" class="section-header"><a href="#examples-79">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_xor-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-8" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-80" class="section-header"><a href="#examples-80">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_max-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-8" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-81" class="section-header"><a href="#examples-81">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">7</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-8" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#709" title="goto source code">[src]</a></div><a href="#method.fetch_min-8" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-8" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.u128.html">u128</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-82" class="section-header"><a href="#examples-82">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7u128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-14" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#impl-14" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_add-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-9" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-83" class="section-header"><a href="#examples-83">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_sub-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-9" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-84" class="section-header"><a href="#examples-84">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_and-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-9" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-85" class="section-header"><a href="#examples-85">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_nand-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-9" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-86" class="section-header"><a href="#examples-86">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_or-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-9" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-87" class="section-header"><a href="#examples-87">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_xor-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-9" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-88" class="section-header"><a href="#examples-88">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_max-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-9" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-89" class="section-header"><a href="#examples-89">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">7</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-9" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#710" title="goto source code">[src]</a></div><a href="#method.fetch_min-9" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-9" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.i128.html">i128</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-90" class="section-header"><a href="#examples-90">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7i128</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-15" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#impl-15" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_add-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-10" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-91" class="section-header"><a href="#examples-91">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_sub-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-10" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-92" class="section-header"><a href="#examples-92">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_and-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-10" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-93" class="section-header"><a href="#examples-93">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_nand-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-10" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-94" class="section-header"><a href="#examples-94">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_or-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-10" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-95" class="section-header"><a href="#examples-95">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_xor-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-10" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-96" class="section-header"><a href="#examples-96">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_max-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-10" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-97" class="section-header"><a href="#examples-97">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-10" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#712-716" title="goto source code">[src]</a></div><a href="#method.fetch_min-10" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-10" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-98" class="section-header"><a href="#examples-98">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7usize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-16" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#impl-16" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_add-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_add-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_add-11" class="fnname">fetch_add</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Increments the current value by <code>val</code> and returns the previous value.</p>
<p>The addition wraps on overflow.</p>
<h5 id="examples-99" class="section-header"><a href="#examples-99">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_add</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">10</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_sub-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_sub-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_sub-11" class="fnname">fetch_sub</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Decrements the current value by <code>val</code> and returns the previous value.</p>
<p>The subtraction wraps on overflow.</p>
<h5 id="examples-100" class="section-header"><a href="#examples-100">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_sub</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_and-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-11" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “and” to the current value and returns the previous value.</p>
<h5 id="examples-101" class="section-header"><a href="#examples-101">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_nand-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-11" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “nand” to the current value and returns the previous value.</p>
<h5 id="examples-102" class="section-header"><a href="#examples-102">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="number">3</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="op">!</span>(<span class="number">7</span> <span class="op">&amp;</span> <span class="number">3</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_or-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-11" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “or” to the current value and returns the previous value.</p>
<h5 id="examples-103" class="section-header"><a href="#examples-103">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="number">16</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">23</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_xor-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-11" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Applies bitwise “xor” to the current value and returns the previous value.</p>
<h5 id="examples-104" class="section-header"><a href="#examples-104">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">5</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_max-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_max-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_max-11" class="fnname">fetch_max</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Compares and sets the maximum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-105" class="section-header"><a href="#examples-105">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_max</span>(<span class="number">9</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">9</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_min-11" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#717-721" title="goto source code">[src]</a></div><a href="#method.fetch_min-11" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_min-11" class="fnname">fetch_min</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.isize.html">isize</a></h4></div></summary><div class="docblock"><p>Compares and sets the minimum of the current value and <code>val</code>,
and returns the previous value.</p>
<h5 id="examples-106" class="section-header"><a href="#examples-106">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="number">7isize</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_min</span>(<span class="number">2</span>), <span class="number">7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-17" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#723-810" title="goto source code">[src]</a></div><a href="#impl-17" class="anchor"></a><h3 class="code-header in-band">impl <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a>&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_and-12" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#740-743" title="goto source code">[src]</a></div><a href="#method.fetch_and-12" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_and-12" class="fnname">fetch_and</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Applies logical “and” to the current value and returns the previous value.</p>
<h5 id="examples-107" class="section-header"><a href="#examples-107">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="bool-val">true</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_and</span>(<span class="bool-val">false</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">false</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_nand-12" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#764-767" title="goto source code">[src]</a></div><a href="#method.fetch_nand-12" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_nand-12" class="fnname">fetch_nand</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Applies logical “nand” to the current value and returns the previous value.</p>
<h5 id="examples-108" class="section-header"><a href="#examples-108">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="bool-val">false</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="bool-val">true</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_nand</span>(<span class="bool-val">false</span>), <span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">true</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_or-12" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#785-788" title="goto source code">[src]</a></div><a href="#method.fetch_or-12" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_or-12" class="fnname">fetch_or</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Applies logical “or” to the current value and returns the previous value.</p>
<h5 id="examples-109" class="section-header"><a href="#examples-109">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="bool-val">false</span>), <span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_or</span>(<span class="bool-val">true</span>), <span class="bool-val">false</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">true</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fetch_xor-12" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#806-809" title="goto source code">[src]</a></div><a href="#method.fetch_xor-12" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.fetch_xor-12" class="fnname">fetch_xor</a>(&amp;self, val: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Applies logical “xor” to the current value and returns the previous value.</p>
<h5 id="examples-110" class="section-header"><a href="#examples-110">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_utils::atomic::AtomicCell</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">AtomicCell::new</span>(<span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="bool-val">false</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">fetch_xor</span>(<span class="bool-val">true</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(<span class="ident">a</span>.<span class="ident">load</span>(), <span class="bool-val">false</span>);</code></pre></div>
</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/crossbeam_utils/atomic/atomic_cell.rs.html#825-831" 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/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> + <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</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/crossbeam_utils/atomic/atomic_cell.rs.html#826-830" 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/crossbeam_utils/atomic/atomic_cell.rs.html#812-816" 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/default/trait.Default.html" title="trait core::default::Default">Default</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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</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/crossbeam_utils/atomic/atomic_cell.rs.html#813-815" 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; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</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/crossbeam_utils/atomic/atomic_cell.rs.html#818-823" 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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</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/crossbeam_utils/atomic/atomic_cell.rs.html#820-822" 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>(val: T) -&gt; <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><div id="impl-RefUnwindSafe" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#48" title="goto source code">[src]</a></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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div><div id="impl-Send" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#42" title="goto source code">[src]</a></div><a href="#impl-Send" 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.Send.html" title="trait core::marker::Send">Send</a>&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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div><div id="impl-Sync" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#43" title="goto source code">[src]</a></div><a href="#impl-Sync" 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.Send.html" title="trait core::marker::Send">Send</a>&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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</h3></div><div id="impl-UnwindSafe" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../../src/crossbeam_utils/atomic/atomic_cell.rs.html#46" title="goto source code">[src]</a></div><a href="#impl-UnwindSafe" 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.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</a>&lt;T&gt;</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-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.AtomicCell.html" title="struct crossbeam_utils::atomic::AtomicCell">AtomicCell</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><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="crossbeam_utils" 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