(function() {var type_impls = {
"arrow":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Array-for-Arc%3Cdyn+Array%3E\" class=\"impl\"><a href=\"#impl-Array-for-Arc%3Cdyn+Array%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl <a class=\"trait\" href=\"arrow/array/trait.Array.html\" title=\"trait arrow::array::Array\">Array</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;dyn <a class=\"trait\" href=\"arrow/array/trait.Array.html\" title=\"trait arrow::array::Array\">Array</a>&gt;</h3></section></summary><div class=\"docblock\"><p>Ergonomics: Allow use of an ArrayRef as an <code>&amp;dyn Array</code></p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_any\" class=\"method trait-impl\"><a href=\"#method.as_any\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.as_any\" class=\"fn\">as_any</a>(&amp;self) -&gt; &amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/any/trait.Any.html\" title=\"trait core::any::Any\">Any</a> + 'static)</h4></section></summary><div class='docblock'>Returns the array as <a href=\"https://doc.rust-lang.org/nightly/core/any/trait.Any.html\" title=\"trait core::any::Any\"><code>Any</code></a> so that it can be\ndowncasted to a specific implementation. <a href=\"arrow/array/trait.Array.html#tymethod.as_any\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.to_data\" class=\"method trait-impl\"><a href=\"#method.to_data\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.to_data\" class=\"fn\">to_data</a>(&amp;self) -&gt; <a class=\"struct\" href=\"arrow/array/struct.ArrayData.html\" title=\"struct arrow::array::ArrayData\">ArrayData</a></h4></section></summary><div class='docblock'>Returns the underlying data of this array</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_data\" class=\"method trait-impl\"><a href=\"#method.into_data\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.into_data\" class=\"fn\">into_data</a>(self) -&gt; <a class=\"struct\" href=\"arrow/array/struct.ArrayData.html\" title=\"struct arrow::array::ArrayData\">ArrayData</a></h4></section></summary><div class='docblock'>Returns the underlying data of this array <a href=\"arrow/array/trait.Array.html#tymethod.into_data\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.data_type\" class=\"method trait-impl\"><a href=\"#method.data_type\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.data_type\" class=\"fn\">data_type</a>(&amp;self) -&gt; &amp;<a class=\"enum\" href=\"arrow/datatypes/enum.DataType.html\" title=\"enum arrow::datatypes::DataType\">DataType</a></h4></section></summary><div class='docblock'>Returns a reference to the <a href=\"arrow/datatypes/enum.DataType.html\" title=\"enum arrow::datatypes::DataType\"><code>DataType</code></a> of this array. <a href=\"arrow/array/trait.Array.html#tymethod.data_type\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.slice\" class=\"method trait-impl\"><a href=\"#method.slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.slice\" class=\"fn\">slice</a>(&amp;self, offset: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>, length: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;dyn <a class=\"trait\" href=\"arrow/array/trait.Array.html\" title=\"trait arrow::array::Array\">Array</a>&gt;</h4></section></summary><div class='docblock'>Returns a zero-copy slice of this array with the indicated offset and length. <a href=\"arrow/array/trait.Array.html#tymethod.slice\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.len\" class=\"method trait-impl\"><a href=\"#method.len\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.len\" class=\"fn\">len</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class='docblock'>Returns the length (i.e., number of elements) of this array. <a href=\"arrow/array/trait.Array.html#tymethod.len\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_empty\" class=\"method trait-impl\"><a href=\"#method.is_empty\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.is_empty\" class=\"fn\">is_empty</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether this array is empty. <a href=\"arrow/array/trait.Array.html#tymethod.is_empty\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.offset\" class=\"method trait-impl\"><a href=\"#method.offset\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.offset\" class=\"fn\">offset</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class='docblock'>Returns the offset into the underlying data used by this array(-slice).\nNote that the underlying data can be shared by many arrays.\nThis defaults to <code>0</code>. <a href=\"arrow/array/trait.Array.html#tymethod.offset\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.nulls\" class=\"method trait-impl\"><a href=\"#method.nulls\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.nulls\" class=\"fn\">nulls</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/buffer/struct.NullBuffer.html\" title=\"struct arrow::buffer::NullBuffer\">NullBuffer</a>&gt;</h4></section></summary><div class='docblock'>Returns the null buffer of this array if any. <a href=\"arrow/array/trait.Array.html#tymethod.nulls\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.logical_nulls\" class=\"method trait-impl\"><a href=\"#method.logical_nulls\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#method.logical_nulls\" class=\"fn\">logical_nulls</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"struct\" href=\"arrow/buffer/struct.NullBuffer.html\" title=\"struct arrow::buffer::NullBuffer\">NullBuffer</a>&gt;</h4></section></summary><div class='docblock'>Returns a potentially computed <a href=\"arrow/buffer/struct.NullBuffer.html\" title=\"struct arrow::buffer::NullBuffer\"><code>NullBuffer</code></a> that represents the logical\nnull values of this array, if any. <a href=\"arrow/array/trait.Array.html#method.logical_nulls\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_null\" class=\"method trait-impl\"><a href=\"#method.is_null\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#method.is_null\" class=\"fn\">is_null</a>(&amp;self, index: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether the element at <code>index</code> is null according to <a href=\"arrow/array/trait.Array.html#tymethod.nulls\" title=\"method arrow::array::Array::nulls\"><code>Array::nulls</code></a> <a href=\"arrow/array/trait.Array.html#method.is_null\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_valid\" class=\"method trait-impl\"><a href=\"#method.is_valid\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#method.is_valid\" class=\"fn\">is_valid</a>(&amp;self, index: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a>) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns whether the element at <code>index</code> is <em>not</em> null, the\nopposite of <a href=\"arrow/array/trait.Array.html#method.is_null\" title=\"method arrow_array::array::Array::is_null::is_null\"><code>Self::is_null</code></a>. <a href=\"arrow/array/trait.Array.html#method.is_valid\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.null_count\" class=\"method trait-impl\"><a href=\"#method.null_count\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#method.null_count\" class=\"fn\">null_count</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class='docblock'>Returns the total number of physical null values in this array. <a href=\"arrow/array/trait.Array.html#method.null_count\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.is_nullable\" class=\"method trait-impl\"><a href=\"#method.is_nullable\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#method.is_nullable\" class=\"fn\">is_nullable</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns <code>false</code> if the array is guaranteed to not contain any logical nulls <a href=\"arrow/array/trait.Array.html#method.is_nullable\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_buffer_memory_size\" class=\"method trait-impl\"><a href=\"#method.get_buffer_memory_size\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.get_buffer_memory_size\" class=\"fn\">get_buffer_memory_size</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class='docblock'>Returns the total number of bytes of memory pointed to by this array.\nThe buffers store bytes in the Arrow memory format, and include the data as well as the validity map.\nNote that this does not always correspond to the exact memory usage of an array,\nsince multiple arrays can share the same buffers or slices thereof.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_array_memory_size\" class=\"method trait-impl\"><a href=\"#method.get_array_memory_size\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/trait.Array.html#tymethod.get_array_memory_size\" class=\"fn\">get_array_memory_size</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class='docblock'>Returns the total number of bytes of memory occupied physically by this array.\nThis value will always be greater than returned by <code>get_buffer_memory_size()</code> and\nincludes the overhead of the data structures that contain the pointers to the various buffers.</div></details></div></details>","Array","arrow::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsArray-for-Arc%3Cdyn+Array%3E\" class=\"impl\"><a href=\"#impl-AsArray-for-Arc%3Cdyn+Array%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl <a class=\"trait\" href=\"arrow/array/cast/trait.AsArray.html\" title=\"trait arrow::array::cast::AsArray\">AsArray</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;dyn <a class=\"trait\" href=\"arrow/array/trait.Array.html\" title=\"trait arrow::array::Array\">Array</a>&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_boolean_opt\" class=\"method trait-impl\"><a href=\"#method.as_boolean_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_boolean_opt\" class=\"fn\">as_boolean_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.BooleanArray.html\" title=\"struct arrow::array::BooleanArray\">BooleanArray</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.BooleanArray.html\" title=\"struct arrow::array::BooleanArray\"><code>BooleanArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_primitive_opt\" class=\"method trait-impl\"><a href=\"#method.as_primitive_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_primitive_opt\" class=\"fn\">as_primitive_opt</a>&lt;T&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.PrimitiveArray.html\" title=\"struct arrow::array::PrimitiveArray\">PrimitiveArray</a>&lt;T&gt;&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ArrowPrimitiveType.html\" title=\"trait arrow::datatypes::ArrowPrimitiveType\">ArrowPrimitiveType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.PrimitiveArray.html\" title=\"struct arrow::array::PrimitiveArray\"><code>PrimitiveArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_bytes_opt\" class=\"method trait-impl\"><a href=\"#method.as_bytes_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_bytes_opt\" class=\"fn\">as_bytes_opt</a>&lt;T&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;T&gt;&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ByteArrayType.html\" title=\"trait arrow::datatypes::ByteArrayType\">ByteArrayType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\"><code>GenericByteArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_byte_view_opt\" class=\"method trait-impl\"><a href=\"#method.as_byte_view_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_byte_view_opt\" class=\"fn\">as_byte_view_opt</a>&lt;T&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;T&gt;&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ByteViewType.html\" title=\"trait arrow::datatypes::ByteViewType\">ByteViewType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\"><code>GenericByteViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_struct_opt\" class=\"method trait-impl\"><a href=\"#method.as_struct_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_struct_opt\" class=\"fn\">as_struct_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.StructArray.html\" title=\"struct arrow::array::StructArray\">StructArray</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.StructArray.html\" title=\"struct arrow::array::StructArray\"><code>StructArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_list_opt\" class=\"method trait-impl\"><a href=\"#method.as_list_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_list_opt\" class=\"fn\">as_list_opt</a>&lt;O&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericListArray.html\" title=\"struct arrow::array::GenericListArray\">GenericListArray</a>&lt;O&gt;&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericListArray.html\" title=\"struct arrow::array::GenericListArray\"><code>GenericListArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fixed_size_binary_opt\" class=\"method trait-impl\"><a href=\"#method.as_fixed_size_binary_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_fixed_size_binary_opt\" class=\"fn\">as_fixed_size_binary_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.FixedSizeBinaryArray.html\" title=\"struct arrow::array::FixedSizeBinaryArray\">FixedSizeBinaryArray</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.FixedSizeBinaryArray.html\" title=\"struct arrow::array::FixedSizeBinaryArray\"><code>FixedSizeBinaryArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fixed_size_list_opt\" class=\"method trait-impl\"><a href=\"#method.as_fixed_size_list_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_fixed_size_list_opt\" class=\"fn\">as_fixed_size_list_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.FixedSizeListArray.html\" title=\"struct arrow::array::FixedSizeListArray\">FixedSizeListArray</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.FixedSizeListArray.html\" title=\"struct arrow::array::FixedSizeListArray\"><code>FixedSizeListArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_map_opt\" class=\"method trait-impl\"><a href=\"#method.as_map_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_map_opt\" class=\"fn\">as_map_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.MapArray.html\" title=\"struct arrow::array::MapArray\">MapArray</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.MapArray.html\" title=\"struct arrow::array::MapArray\"><code>MapArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_dictionary_opt\" class=\"method trait-impl\"><a href=\"#method.as_dictionary_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_dictionary_opt\" class=\"fn\">as_dictionary_opt</a>&lt;K&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.DictionaryArray.html\" title=\"struct arrow::array::DictionaryArray\">DictionaryArray</a>&lt;K&gt;&gt;<div class=\"where\">where\n    K: <a class=\"trait\" href=\"arrow/datatypes/trait.ArrowDictionaryKeyType.html\" title=\"trait arrow::datatypes::ArrowDictionaryKeyType\">ArrowDictionaryKeyType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.DictionaryArray.html\" title=\"struct arrow::array::DictionaryArray\"><code>DictionaryArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_any_dictionary_opt\" class=\"method trait-impl\"><a href=\"#method.as_any_dictionary_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#tymethod.as_any_dictionary_opt\" class=\"fn\">as_any_dictionary_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"arrow/array/trait.AnyDictionaryArray.html\" title=\"trait arrow::array::AnyDictionaryArray\">AnyDictionaryArray</a>&gt;</h4></section></summary><div class='docblock'>Downcasts this to a <a href=\"arrow/array/trait.AnyDictionaryArray.html\" title=\"trait arrow::array::AnyDictionaryArray\"><code>AnyDictionaryArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_boolean\" class=\"method trait-impl\"><a href=\"#method.as_boolean\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_boolean\" class=\"fn\">as_boolean</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.BooleanArray.html\" title=\"struct arrow::array::BooleanArray\">BooleanArray</a></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.BooleanArray.html\" title=\"struct arrow::array::BooleanArray\"><code>BooleanArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_primitive\" class=\"method trait-impl\"><a href=\"#method.as_primitive\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_primitive\" class=\"fn\">as_primitive</a>&lt;T&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.PrimitiveArray.html\" title=\"struct arrow::array::PrimitiveArray\">PrimitiveArray</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ArrowPrimitiveType.html\" title=\"trait arrow::datatypes::ArrowPrimitiveType\">ArrowPrimitiveType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.PrimitiveArray.html\" title=\"struct arrow::array::PrimitiveArray\"><code>PrimitiveArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_bytes\" class=\"method trait-impl\"><a href=\"#method.as_bytes\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_bytes\" class=\"fn\">as_bytes</a>&lt;T&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ByteArrayType.html\" title=\"trait arrow::datatypes::ByteArrayType\">ByteArrayType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\"><code>GenericByteArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_string_opt\" class=\"method trait-impl\"><a href=\"#method.as_string_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_string_opt\" class=\"fn\">as_string_opt</a>&lt;O&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.GenericStringType.html\" title=\"struct arrow::datatypes::GenericStringType\">GenericStringType</a>&lt;O&gt;&gt;&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.GenericStringArray.html\" title=\"type arrow::array::GenericStringArray\"><code>GenericStringArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_string\" class=\"method trait-impl\"><a href=\"#method.as_string\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_string\" class=\"fn\">as_string</a>&lt;O&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.GenericStringType.html\" title=\"struct arrow::datatypes::GenericStringType\">GenericStringType</a>&lt;O&gt;&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.GenericStringArray.html\" title=\"type arrow::array::GenericStringArray\"><code>GenericStringArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_binary_opt\" class=\"method trait-impl\"><a href=\"#method.as_binary_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_binary_opt\" class=\"fn\">as_binary_opt</a>&lt;O&gt;(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.GenericBinaryType.html\" title=\"struct arrow::datatypes::GenericBinaryType\">GenericBinaryType</a>&lt;O&gt;&gt;&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.GenericBinaryArray.html\" title=\"type arrow::array::GenericBinaryArray\"><code>GenericBinaryArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_binary\" class=\"method trait-impl\"><a href=\"#method.as_binary\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_binary\" class=\"fn\">as_binary</a>&lt;O&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteArray.html\" title=\"struct arrow::array::GenericByteArray\">GenericByteArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.GenericBinaryType.html\" title=\"struct arrow::datatypes::GenericBinaryType\">GenericBinaryType</a>&lt;O&gt;&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.GenericBinaryArray.html\" title=\"type arrow::array::GenericBinaryArray\"><code>GenericBinaryArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_string_view\" class=\"method trait-impl\"><a href=\"#method.as_string_view\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_string_view\" class=\"fn\">as_string_view</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.StringViewType.html\" title=\"struct arrow::datatypes::StringViewType\">StringViewType</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.StringViewArray.html\" title=\"type arrow::array::StringViewArray\"><code>StringViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_string_view_opt\" class=\"method trait-impl\"><a href=\"#method.as_string_view_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_string_view_opt\" class=\"fn\">as_string_view_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.StringViewType.html\" title=\"struct arrow::datatypes::StringViewType\">StringViewType</a>&gt;&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.StringViewArray.html\" title=\"type arrow::array::StringViewArray\"><code>StringViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_binary_view\" class=\"method trait-impl\"><a href=\"#method.as_binary_view\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_binary_view\" class=\"fn\">as_binary_view</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.BinaryViewType.html\" title=\"struct arrow::datatypes::BinaryViewType\">BinaryViewType</a>&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.StringViewArray.html\" title=\"type arrow::array::StringViewArray\"><code>StringViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_binary_view_opt\" class=\"method trait-impl\"><a href=\"#method.as_binary_view_opt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_binary_view_opt\" class=\"fn\">as_binary_view_opt</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;<a class=\"struct\" href=\"arrow/datatypes/struct.BinaryViewType.html\" title=\"struct arrow::datatypes::BinaryViewType\">BinaryViewType</a>&gt;&gt;</h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/type.BinaryViewArray.html\" title=\"type arrow::array::BinaryViewArray\"><code>BinaryViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_byte_view\" class=\"method trait-impl\"><a href=\"#method.as_byte_view\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_byte_view\" class=\"fn\">as_byte_view</a>&lt;T&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\">GenericByteViewArray</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"arrow/datatypes/trait.ByteViewType.html\" title=\"trait arrow::datatypes::ByteViewType\">ByteViewType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericByteViewArray.html\" title=\"struct arrow::array::GenericByteViewArray\"><code>GenericByteViewArray</code></a> returning <code>None</code> if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_struct\" class=\"method trait-impl\"><a href=\"#method.as_struct\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_struct\" class=\"fn\">as_struct</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.StructArray.html\" title=\"struct arrow::array::StructArray\">StructArray</a></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.StructArray.html\" title=\"struct arrow::array::StructArray\"><code>StructArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_list\" class=\"method trait-impl\"><a href=\"#method.as_list\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_list\" class=\"fn\">as_list</a>&lt;O&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.GenericListArray.html\" title=\"struct arrow::array::GenericListArray\">GenericListArray</a>&lt;O&gt;<div class=\"where\">where\n    O: <a class=\"trait\" href=\"arrow/array/trait.OffsetSizeTrait.html\" title=\"trait arrow::array::OffsetSizeTrait\">OffsetSizeTrait</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.GenericListArray.html\" title=\"struct arrow::array::GenericListArray\"><code>GenericListArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fixed_size_binary\" class=\"method trait-impl\"><a href=\"#method.as_fixed_size_binary\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_fixed_size_binary\" class=\"fn\">as_fixed_size_binary</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.FixedSizeBinaryArray.html\" title=\"struct arrow::array::FixedSizeBinaryArray\">FixedSizeBinaryArray</a></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.FixedSizeBinaryArray.html\" title=\"struct arrow::array::FixedSizeBinaryArray\"><code>FixedSizeBinaryArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fixed_size_list\" class=\"method trait-impl\"><a href=\"#method.as_fixed_size_list\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_fixed_size_list\" class=\"fn\">as_fixed_size_list</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.FixedSizeListArray.html\" title=\"struct arrow::array::FixedSizeListArray\">FixedSizeListArray</a></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.FixedSizeListArray.html\" title=\"struct arrow::array::FixedSizeListArray\"><code>FixedSizeListArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_map\" class=\"method trait-impl\"><a href=\"#method.as_map\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_map\" class=\"fn\">as_map</a>(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.MapArray.html\" title=\"struct arrow::array::MapArray\">MapArray</a></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.MapArray.html\" title=\"struct arrow::array::MapArray\"><code>MapArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_dictionary\" class=\"method trait-impl\"><a href=\"#method.as_dictionary\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_dictionary\" class=\"fn\">as_dictionary</a>&lt;K&gt;(&amp;self) -&gt; &amp;<a class=\"struct\" href=\"arrow/array/struct.DictionaryArray.html\" title=\"struct arrow::array::DictionaryArray\">DictionaryArray</a>&lt;K&gt;<div class=\"where\">where\n    K: <a class=\"trait\" href=\"arrow/datatypes/trait.ArrowDictionaryKeyType.html\" title=\"trait arrow::datatypes::ArrowDictionaryKeyType\">ArrowDictionaryKeyType</a>,</div></h4></section></summary><div class='docblock'>Downcast this to a <a href=\"arrow/array/struct.DictionaryArray.html\" title=\"struct arrow::array::DictionaryArray\"><code>DictionaryArray</code></a> panicking if not possible</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_any_dictionary\" class=\"method trait-impl\"><a href=\"#method.as_any_dictionary\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"arrow/array/cast/trait.AsArray.html#method.as_any_dictionary\" class=\"fn\">as_any_dictionary</a>(&amp;self) -&gt; &amp;dyn <a class=\"trait\" href=\"arrow/array/trait.AnyDictionaryArray.html\" title=\"trait arrow::array::AnyDictionaryArray\">AnyDictionaryArray</a></h4></section></summary><div class='docblock'>Downcasts this to a <a href=\"arrow/array/trait.AnyDictionaryArray.html\" title=\"trait arrow::array::AnyDictionaryArray\"><code>AnyDictionaryArray</code></a> panicking if not possible</div></details></div></details>","AsArray","arrow::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","arrow::array::ArrayDataRef","arrow::array::ArrayRef","arrow::datatypes::FieldRef","arrow::datatypes::SchemaRef"]],
"arrow_array":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","arrow_array::array::ArrayRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","arrow_array::array::ArrayRef"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","arrow_array::array::ArrayRef"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","arrow_array::array::ArrayRef"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","arrow_array::array::ArrayRef"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","arrow_array::array::ArrayRef"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","arrow_array::array::ArrayRef"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","arrow_array::array::ArrayRef"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","arrow_array::array::ArrayRef"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","arrow_array::array::ArrayRef"]],
"arrow_data":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","arrow_data::data::ArrayDataRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","arrow_data::data::ArrayDataRef"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","arrow_data::data::ArrayDataRef"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","arrow_data::data::ArrayDataRef"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","arrow_data::data::ArrayDataRef"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","arrow_data::data::ArrayDataRef"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","arrow_data::data::ArrayDataRef"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","arrow_data::data::ArrayDataRef"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","arrow_data::data::ArrayDataRef"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","arrow_data::data::ArrayDataRef"]],
"arrow_flight":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-LocalSpawn-for-Arc%3CSp%3E\" class=\"impl\"><a href=\"#impl-LocalSpawn-for-Arc%3CSp%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;Sp&gt; LocalSpawn for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;Sp&gt;<div class=\"where\">where\n    Sp: LocalSpawn + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.spawn_local_obj\" class=\"method trait-impl\"><a href=\"#method.spawn_local_obj\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">spawn_local_obj</a>(\n    &amp;self,\n    future: LocalFutureObj&lt;'static, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>&gt;\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Spawns a future that will be run to completion. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.status_local\" class=\"method trait-impl\"><a href=\"#method.status_local\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">status_local</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Determines whether the executor is able to spawn new tasks. <a>Read more</a></div></details></div></details>","LocalSpawn","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Log-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/log/0.4.21/src/log/lib.rs.html#1201-1203\">source</a><a href=\"#impl-Log-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/log/0.4.21/log/trait.Log.html\" title=\"trait log::Log\">Log</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/log/0.4.21/log/trait.Log.html\" title=\"trait log::Log\">Log</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.enabled\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/log/0.4.21/src/log/lib.rs.html#1205\">source</a><a href=\"#method.enabled\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/log/0.4.21/log/trait.Log.html#tymethod.enabled\" class=\"fn\">enabled</a>(&amp;self, metadata: &amp;<a class=\"struct\" href=\"https://docs.rs/log/0.4.21/log/struct.Metadata.html\" title=\"struct log::Metadata\">Metadata</a>&lt;'_&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Determines if a log message with the specified metadata would be\nlogged. <a href=\"https://docs.rs/log/0.4.21/log/trait.Log.html#tymethod.enabled\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.log\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/log/0.4.21/src/log/lib.rs.html#1209\">source</a><a href=\"#method.log\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/log/0.4.21/log/trait.Log.html#tymethod.log\" class=\"fn\">log</a>(&amp;self, record: &amp;<a class=\"struct\" href=\"https://docs.rs/log/0.4.21/log/struct.Record.html\" title=\"struct log::Record\">Record</a>&lt;'_&gt;)</h4></section></summary><div class='docblock'>Logs the <code>Record</code>. <a href=\"https://docs.rs/log/0.4.21/log/trait.Log.html#tymethod.log\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.flush\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/log/0.4.21/src/log/lib.rs.html#1212\">source</a><a href=\"#method.flush\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/log/0.4.21/log/trait.Log.html#tymethod.flush\" class=\"fn\">flush</a>(&amp;self)</h4></section></summary><div class='docblock'>Flushes any buffered records.</div></details></div></details>","Log","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Spawn-for-Arc%3CSp%3E\" class=\"impl\"><a href=\"#impl-Spawn-for-Arc%3CSp%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;Sp&gt; Spawn for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;Sp&gt;<div class=\"where\">where\n    Sp: Spawn + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.spawn_obj\" class=\"method trait-impl\"><a href=\"#method.spawn_obj\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">spawn_obj</a>(&amp;self, future: FutureObj&lt;'static, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Spawns a future that will be run to completion. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.status\" class=\"method trait-impl\"><a href=\"#method.status\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">status</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Determines whether the executor is able to spawn new tasks. <a>Read more</a></div></details></div></details>","Spawn","arrow_flight::trailers::SharedTrailers"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Subscriber-for-Arc%3CS%3E\" class=\"impl\"><a href=\"#impl-Subscriber-for-Arc%3CS%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;S&gt; Subscriber for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;S&gt;<div class=\"where\">where\n    S: Subscriber + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.register_callsite\" class=\"method trait-impl\"><a href=\"#method.register_callsite\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">register_callsite</a>(&amp;self, metadata: &amp;'static Metadata&lt;'static&gt;) -&gt; Interest</h4></section></summary><div class='docblock'>Registers a new <a href=\"crate::callsite\">callsite</a> with this subscriber, returning whether or not\nthe subscriber is interested in being notified about the callsite. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.enabled\" class=\"method trait-impl\"><a href=\"#method.enabled\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">enabled</a>(&amp;self, metadata: &amp;Metadata&lt;'_&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Returns true if a span or event with the specified <a href=\"super::metadata::Metadata\">metadata</a> would be\nrecorded. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max_level_hint\" class=\"method trait-impl\"><a href=\"#method.max_level_hint\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">max_level_hint</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;LevelFilter&gt;</h4></section></summary><div class='docblock'>Returns the highest <a href=\"super::Level\">verbosity level</a> that this <code>Subscriber</code> will\nenable, or <code>None</code>, if the subscriber does not implement level-based\nfiltering or chooses not to implement this method. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_span\" class=\"method trait-impl\"><a href=\"#method.new_span\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">new_span</a>(&amp;self, span: &amp;Attributes&lt;'_&gt;) -&gt; Id</h4></section></summary><div class='docblock'>Visit the construction of a new span, returning a new <a href=\"super::span::Id\">span ID</a> for the\nspan being constructed. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.record\" class=\"method trait-impl\"><a href=\"#method.record\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">record</a>(&amp;self, span: &amp;Id, values: &amp;Record&lt;'_&gt;)</h4></section></summary><div class='docblock'>Record a set of values on a span. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.record_follows_from\" class=\"method trait-impl\"><a href=\"#method.record_follows_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">record_follows_from</a>(&amp;self, span: &amp;Id, follows: &amp;Id)</h4></section></summary><div class='docblock'>Adds an indication that <code>span</code> follows from the span with the id\n<code>follows</code>. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.event_enabled\" class=\"method trait-impl\"><a href=\"#method.event_enabled\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">event_enabled</a>(&amp;self, event: &amp;Event&lt;'_&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Determine if an [<code>Event</code>] should be recorded. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.event\" class=\"method trait-impl\"><a href=\"#method.event\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">event</a>(&amp;self, event: &amp;Event&lt;'_&gt;)</h4></section></summary><div class='docblock'>Records that an <a href=\"super::event::Event\"><code>Event</code></a> has occurred. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.enter\" class=\"method trait-impl\"><a href=\"#method.enter\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">enter</a>(&amp;self, span: &amp;Id)</h4></section></summary><div class='docblock'>Records that a span has been entered. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.exit\" class=\"method trait-impl\"><a href=\"#method.exit\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">exit</a>(&amp;self, span: &amp;Id)</h4></section></summary><div class='docblock'>Records that a span has been exited. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_span\" class=\"method trait-impl\"><a href=\"#method.clone_span\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">clone_span</a>(&amp;self, id: &amp;Id) -&gt; Id</h4></section></summary><div class='docblock'>Notifies the subscriber that a <a href=\"super::span::Id\">span ID</a> has been cloned. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_close\" class=\"method trait-impl\"><a href=\"#method.try_close\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">try_close</a>(&amp;self, id: Id) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class='docblock'>Notifies the subscriber that a <a href=\"super::span::Id\">span ID</a> has been dropped, and returns\n<code>true</code> if there are now 0 IDs that refer to that span. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop_span\" class=\"method trait-impl\"><a href=\"#method.drop_span\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">drop_span</a>(&amp;self, id: Id)</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 0.1.2: use <code>Subscriber::try_close</code> instead</span></div></span><div class='docblock'><strong>This method is deprecated.</strong> <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.current_span\" class=\"method trait-impl\"><a href=\"#method.current_span\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">current_span</a>(&amp;self) -&gt; Current</h4></section></summary><div class='docblock'>Returns a type representing this subscriber’s view of the current span. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downcast_raw\" class=\"method trait-impl\"><a href=\"#method.downcast_raw\" class=\"anchor\">§</a><h4 class=\"code-header\">unsafe fn <a class=\"fn\">downcast_raw</a>(&amp;self, id: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html\" title=\"struct core::any::TypeId\">TypeId</a>) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const </a><a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>&gt;</h4></section></summary><div class='docblock'>If <code>self</code> is the same type as the provided <code>TypeId</code>, returns an untyped\n<code>*const</code> pointer to that type. Otherwise, returns <code>None</code>. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.on_register_dispatch\" class=\"method trait-impl\"><a href=\"#method.on_register_dispatch\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">on_register_dispatch</a>(&amp;self, subscriber: &amp;Dispatch)</h4></section></summary><div class='docblock'>Invoked when this subscriber becomes a [<code>Dispatch</code>]. <a>Read more</a></div></details></div></details>","Subscriber","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","arrow_flight::trailers::SharedTrailers"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","arrow_flight::trailers::SharedTrailers"]],
"arrow_schema":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","arrow_schema::field::FieldRef","arrow_schema::schema::SchemaRef"]],
"parquet":[["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1340\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1402\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw\" class=\"fn\">from_raw</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw(x_ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32]&gt; = Arc::new([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>]&gt; = Arc::from_raw(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;());\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1434\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count\" class=\"fn\">increment_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.51.0\">1.51.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1470\">source</a></span><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count\" class=\"fn\">decrement_strong_count</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>)</h4></section></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count(ptr);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count(ptr);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#379\">source</a><a href=\"#impl-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.new\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#392\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new\" class=\"fn\">new</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_cyclic\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.60.0\">1.60.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#457-459\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_cyclic\" class=\"fn\">new_cyclic</a>&lt;F&gt;(data_fn: F) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    F: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/function/trait.FnOnce.html\" title=\"trait core::ops::function::FnOnce\">FnOnce</a>(&amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T&gt;) -&gt; T,</div></h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> while giving you a <code>Weak&lt;T&gt;</code> to the allocation,\nto allow you to construct a <code>T</code> which holds a weak pointer to itself.</p>\n<p>Generally, a structure circularly referencing itself, either directly or\nindirectly, should not hold a strong reference to itself to prevent a memory leak.\nUsing this function, you get access to the weak pointer during the\ninitialization of <code>T</code>, before the <code>Arc&lt;T&gt;</code> is created, such that you can\nclone and store it inside the <code>T</code>.</p>\n<p><code>new_cyclic</code> first allocates the managed allocation for the <code>Arc&lt;T&gt;</code>,\nthen calls your closure, giving it a <code>Weak&lt;T&gt;</code> to this allocation,\nand only afterwards completes the construction of the <code>Arc&lt;T&gt;</code> by placing\nthe <code>T</code> returned from your closure into the allocation.</p>\n<p>Since the new <code>Arc&lt;T&gt;</code> is not fully-constructed until <code>Arc&lt;T&gt;::new_cyclic</code>\nreturns, calling <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html#method.upgrade\" title=\"method alloc::sync::Weak::upgrade\"><code>upgrade</code></a> on the weak reference inside your closure will\nfail and result in a <code>None</code> value.</p>\n<h5 id=\"panics\"><a class=\"doc-anchor\" href=\"#panics\">§</a>Panics</h5>\n<p>If <code>data_fn</code> panics, the panic is propagated to the caller, and the\ntemporary <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak&lt;T&gt;</code></a> is dropped normally.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::{Arc, Weak};\n\n<span class=\"kw\">struct </span>Gadget {\n    me: Weak&lt;Gadget&gt;,\n}\n\n<span class=\"kw\">impl </span>Gadget {\n    <span class=\"doccomment\">/// Construct a reference counted Gadget.\n    </span><span class=\"kw\">fn </span>new() -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"comment\">// `me` is a `Weak&lt;Gadget&gt;` pointing at the new allocation of the\n        // `Arc` we're constructing.\n        </span>Arc::new_cyclic(|me| {\n            <span class=\"comment\">// Create the actual struct here.\n            </span>Gadget { me: me.clone() }\n        })\n    }\n\n    <span class=\"doccomment\">/// Return a reference counted pointer to Self.\n    </span><span class=\"kw\">fn </span>me(<span class=\"kw-2\">&amp;</span><span class=\"self\">self</span>) -&gt; Arc&lt;<span class=\"self\">Self</span>&gt; {\n        <span class=\"self\">self</span>.me.upgrade().unwrap()\n    }\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#534\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit\" class=\"fn\">new_uninit</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::new_uninit();\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#568\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed\" class=\"fn\">new_zeroed</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>new_uninit</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::new_zeroed();\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#583\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin\" class=\"fn\">pin</a>(data: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>. If <code>T</code> does not implement <code>Unpin</code>, then\n<code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#590\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin\" class=\"fn\">try_pin</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T&gt;&gt;</code>, return an error if allocation fails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#607\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new\" class=\"fn\">try_new</a>(data: T) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code>, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::try_new(<span class=\"number\">5</span>)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#641\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit\" class=\"fn\">try_new_uninit</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, returning an error\nif allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32&gt;::try_new_uninit()<span class=\"question-mark\">?</span>;\n\n<span class=\"comment\">// Deferred initialization:\n</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>five).unwrap().write(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{ five.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#674\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed\" class=\"fn\">try_new_zeroed</a>() -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, returning an error if allocation fails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32&gt;::try_new_zeroed()<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1475\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1493\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw\" class=\"fn\">into_raw</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw\" title=\"associated function alloc::sync::Arc::from_raw\"><code>Arc::from_raw</code></a>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_raw_with_allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1519\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_raw_with_allocator\" class=\"fn\">into_raw_with_allocator</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; (<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Consumes the <code>Arc</code>, returning the wrapped pointer and allocator.</p>\n<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.from_raw_in\" title=\"associated function alloc::sync::Arc::from_raw_in\"><code>Arc::from_raw_in</code></a>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>(ptr, alloc) = Arc::into_raw_with_allocator(x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>ptr }, <span class=\"string\">\"hello\"</span>);\n<span class=\"kw\">let </span>x = <span class=\"kw\">unsafe </span>{ Arc::from_raw_in(ptr, alloc) };\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ptr\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1546\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.as_ptr\" class=\"fn\">as_ptr</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a></h4></section></summary><div class=\"docblock\"><p>Provides a raw pointer to the data.</p>\n<p>The counts are not affected in any way and the <code>Arc</code> is not consumed. The pointer is valid for\nas long as there are strong counts in the <code>Arc</code>.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"string\">\"hello\"</span>.to_owned());\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"kw\">let </span>x_ptr = Arc::as_ptr(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(x_ptr, Arc::as_ptr(<span class=\"kw-2\">&amp;</span>y));\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw\">unsafe </span>{ <span class=\"kw-2\">&amp;*</span>x_ptr }, <span class=\"string\">\"hello\"</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.from_raw_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1624\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.from_raw_in\" class=\"fn\">from_raw_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs an <code>Arc&lt;T, A&gt;</code> from a raw pointer.</p>\n<p>The raw pointer must have been previously returned by a call to <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_raw\" title=\"associated function alloc::sync::Arc::into_raw\"><code>Arc&lt;U, A&gt;::into_raw</code></a> with the following requirements:</p>\n<ul>\n<li>If <code>U</code> is sized, it must have the same size and alignment as <code>T</code>. This\nis trivially true if <code>U</code> is <code>T</code>.</li>\n<li>If <code>U</code> is unsized, its data pointer must have the same size and\nalignment as <code>T</code>. This is trivially true if <code>Arc&lt;U&gt;</code> was constructed\nthrough <code>Arc&lt;T&gt;</code> and then converted to <code>Arc&lt;U&gt;</code> through an <a href=\"https://doc.rust-lang.org/reference/type-coercions.html#unsized-coercions\">unsized\ncoercion</a>.</li>\n</ul>\n<p>Note that if <code>U</code> or <code>U</code>’s data pointer is not <code>T</code> but has the same size\nand alignment, this is basically like transmuting references of\ndifferent types. See <a href=\"https://doc.rust-lang.org/nightly/core/intrinsics/fn.transmute.html\" title=\"fn core::intrinsics::transmute\"><code>mem::transmute</code></a> for more information\non what restrictions apply in this case.</p>\n<p>The raw pointer must point to a block of memory allocated by <code>alloc</code></p>\n<p>The user of <code>from_raw</code> has to make sure a specific value of <code>T</code> is only\ndropped once.</p>\n<p>This function is unsafe because improper use may lead to memory unsafety,\neven if the returned <code>Arc&lt;T&gt;</code> is never accessed.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x = Arc::new_in(<span class=\"string\">\"hello\"</span>.to_owned(), System);\n<span class=\"kw\">let </span>x_ptr = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Convert back to an `Arc` to prevent leak.\n    </span><span class=\"kw\">let </span>x = Arc::from_raw_in(x_ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"string\">\"hello\"</span>);\n\n    <span class=\"comment\">// Further calls to `Arc::from_raw(x_ptr)` would be memory-unsafe.\n</span>}\n\n<span class=\"comment\">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></code></pre></div>\n<p>Convert a slice back into its original array:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>x: Arc&lt;[u32], <span class=\"kw\">_</span>&gt; = Arc::new_in([<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>], System);\n<span class=\"kw\">let </span>x_ptr: <span class=\"kw-2\">*const </span>[u32] = Arc::into_raw(x);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>x: Arc&lt;[u32; <span class=\"number\">3</span>], <span class=\"kw\">_</span>&gt; = Arc::from_raw_in(x_ptr.cast::&lt;[u32; <span class=\"number\">3</span>]&gt;(), System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">&amp;*</span>x, <span class=\"kw-2\">&amp;</span>[<span class=\"number\">1</span>, <span class=\"number\">2</span>, <span class=\"number\">3</span>]);\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.downgrade\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1649-1651\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.downgrade\" class=\"fn\">downgrade</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\">Weak</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section></summary><div class=\"docblock\"><p>Creates a new <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointer to this allocation.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let </span>weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.weak_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1709\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.weak_count\" class=\"fn\">weak_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to this allocation.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the weak count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_weak_five = Arc::downgrade(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` or `Weak` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::weak_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.strong_count\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.15.0\">1.15.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1739\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.strong_count\" class=\"fn\">strong_count</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.usize.html\">usize</a></h4></section></summary><div class=\"docblock\"><p>Gets the number of strong (<code>Arc</code>) pointers to this allocation.</p>\n<h5 id=\"safety-1\"><a class=\"doc-anchor\" href=\"#safety-1\">§</a>Safety</h5>\n<p>This method by itself is safe, but using it correctly requires extra care.\nAnother thread can change the strong count at any time,\nincluding potentially between calling this method and acting on the result.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>_also_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n\n<span class=\"comment\">// This assertion is deterministic because we haven't shared\n// the `Arc` between threads.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.increment_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1775-1777\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.increment_strong_count_in\" class=\"fn\">increment_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Increments the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-2\"><a class=\"doc-anchor\" href=\"#safety-2\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>, and the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) for the duration of this method,, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// This assertion is deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.decrement_strong_count_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1821\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.decrement_strong_count_in\" class=\"fn\">decrement_strong_count_in</a>(ptr: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.pointer.html\">*const T</a>, alloc: A)</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Decrements the strong reference count on the <code>Arc&lt;T&gt;</code> associated with the\nprovided pointer by one.</p>\n<h5 id=\"safety-3\"><a class=\"doc-anchor\" href=\"#safety-3\">§</a>Safety</h5>\n<p>The pointer must have been obtained through <code>Arc::into_raw</code>,  the\nassociated <code>Arc</code> instance must be valid (i.e. the strong count must be at\nleast 1) when invoking this method, and <code>ptr</code> must point to a block of memory\nallocated by <code>alloc</code>. This method can be used to release the final\n<code>Arc</code> and backing storage, but <strong>should not</strong> be called after the final <code>Arc</code> has been\nreleased.</p>\n<h5 id=\"examples-8\"><a class=\"doc-anchor\" href=\"#examples-8\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);\n\n<span class=\"kw\">unsafe </span>{\n    <span class=\"kw\">let </span>ptr = Arc::into_raw(five);\n    Arc::increment_strong_count_in(ptr, System);\n\n    <span class=\"comment\">// Those assertions are deterministic because we haven't shared\n    // the `Arc` between threads.\n    </span><span class=\"kw\">let </span>five = Arc::from_raw_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">2</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n    Arc::decrement_strong_count_in(ptr, System);\n    <span class=\"macro\">assert_eq!</span>(<span class=\"number\">1</span>, Arc::strong_count(<span class=\"kw-2\">&amp;</span>five));\n}</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ptr_eq\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.17.0\">1.17.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1869\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.ptr_eq\" class=\"fn\">ptr_eq</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Returns <code>true</code> if the two <code>Arc</code>s point to the same allocation in a vein similar to\n<a href=\"https://doc.rust-lang.org/nightly/core/ptr/fn.eq.html\" title=\"ptr::eq\"><code>ptr::eq</code></a>. This function ignores the metadata of  <code>dyn Trait</code> pointers.</p>\n<h5 id=\"examples-9\"><a class=\"doc-anchor\" href=\"#examples-9\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n<span class=\"kw\">let </span>same_five = Arc::clone(<span class=\"kw-2\">&amp;</span>five);\n<span class=\"kw\">let </span>other_five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>same_five));\n<span class=\"macro\">assert!</span>(!Arc::ptr_eq(<span class=\"kw-2\">&amp;</span>five, <span class=\"kw-2\">&amp;</span>other_five));</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2152\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.make_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2206\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.make_mut\" class=\"fn\">make_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section></summary><div class=\"docblock\"><p>Makes a mutable reference into the given <code>Arc</code>.</p>\n<p>If there are other <code>Arc</code> pointers to the same allocation, then <code>make_mut</code> will\n<a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a> the inner value to a new allocation to ensure unique ownership.  This is also\nreferred to as clone-on-write.</p>\n<p>However, if there are no other <code>Arc</code> pointers to this allocation, but some <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>\npointers, then the <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated and the inner value will not\nbe cloned.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which will fail rather than cloning the inner value\nor dissociating <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>other_data = Arc::clone(<span class=\"kw-2\">&amp;</span>data); <span class=\"comment\">// Won't clone inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Clones inner data\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;         <span class=\"comment\">// Won't clone anything\n</span><span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>other_data) <span class=\"kw-2\">*</span>= <span class=\"number\">2</span>;   <span class=\"comment\">// Won't clone anything\n\n// Now `data` and `other_data` point to different allocations.\n</span><span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>data, <span class=\"number\">8</span>);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>other_data, <span class=\"number\">12</span>);</code></pre></div>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers will be dissociated:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>data = Arc::new(<span class=\"number\">75</span>);\n<span class=\"kw\">let </span>weak = Arc::downgrade(<span class=\"kw-2\">&amp;</span>data);\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(<span class=\"number\">75 </span>== <span class=\"kw-2\">*</span>weak.upgrade().unwrap());\n\n<span class=\"kw-2\">*</span>Arc::make_mut(<span class=\"kw-2\">&amp;mut </span>data) += <span class=\"number\">1</span>;\n\n<span class=\"macro\">assert!</span>(<span class=\"number\">76 </span>== <span class=\"kw-2\">*</span>data);\n<span class=\"macro\">assert!</span>(weak.upgrade().is_none());</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2260\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.unwrap_or_clone\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.76.0\">1.76.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2291\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.unwrap_or_clone\" class=\"fn\">unwrap_or_clone</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; T</h4></section></summary><div class=\"docblock\"><p>If we have the only reference to <code>T</code> then unwrap it. Otherwise, clone <code>T</code> and return the\nclone.</p>\n<p>Assuming <code>arc_t</code> is of type <code>Arc&lt;T&gt;</code>, this function is functionally equivalent to\n<code>(*arc_t).clone()</code>, but will avoid cloning the inner value where possible.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>inner = String::from(<span class=\"string\">\"test\"</span>);\n<span class=\"kw\">let </span>ptr = inner.as_ptr();\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// The inner value was not cloned\n</span><span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));\n\n<span class=\"kw\">let </span>arc = Arc::new(inner);\n<span class=\"kw\">let </span>arc2 = arc.clone();\n<span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc);\n<span class=\"comment\">// Because there were 2 references, we had to clone the inner value.\n</span><span class=\"macro\">assert!</span>(!ptr::eq(ptr, inner.as_ptr()));\n<span class=\"comment\">// `arc2` is the last reference, so when we unwrap it we get back\n// the original `String`.\n</span><span class=\"kw\">let </span>inner = Arc::unwrap_or_clone(arc2);\n<span class=\"macro\">assert!</span>(ptr::eq(ptr, inner.as_ptr()));</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2296\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2323\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut\" class=\"fn\">get_mut</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>, if there are\nno other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation.</p>\n<p>Returns <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> otherwise, because it is not safe to\nmutate a shared value.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.make_mut\" title=\"associated function alloc::sync::Arc::make_mut\"><code>make_mut</code></a>, which will <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" title=\"method core::clone::Clone::clone\"><code>clone</code></a>\nthe inner value when there are other <code>Arc</code> pointers.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw-2\">*</span>Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).unwrap() = <span class=\"number\">4</span>;\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">4</span>);\n\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert!</span>(Arc::get_mut(<span class=\"kw-2\">&amp;mut </span>x).is_none());</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.get_mut_unchecked\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2398\">source</a><h4 class=\"code-header\">pub unsafe fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.get_mut_unchecked\" class=\"fn\">get_mut_unchecked</a>(this: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut T</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>get_mut_unchecked</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a mutable reference into the given <code>Arc</code>,\nwithout any check.</p>\n<p>See also <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.get_mut\" title=\"associated function alloc::sync::Arc::get_mut\"><code>get_mut</code></a>, which is safe and does appropriate checks.</p>\n<h5 id=\"safety\"><a class=\"doc-anchor\" href=\"#safety\">§</a>Safety</h5>\n<p>If any other <code>Arc</code> or <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a> pointers to the same allocation exist, then\nthey must not be dereferenced or have active borrows for the duration\nof the returned borrow, and their inner type must be exactly the same as the\ninner type of this Rc (including lifetimes). This is trivially the case if no\nsuch pointers exist, for example immediately after <code>Arc::new</code>.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = Arc::new(String::new());\n<span class=\"kw\">unsafe </span>{\n    Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>x).push_str(<span class=\"string\">\"foo\"</span>)\n}\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"string\">\"foo\"</span>);</code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the same type.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;str&gt; = Arc::from(<span class=\"string\">\"Hello, world!\"</span>);\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;[u8]&gt; = x.clone().into();\n<span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// this is Undefined Behavior, because x's inner type is str, not [u8]\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y).fill(<span class=\"number\">0xff</span>); <span class=\"comment\">// 0xff is invalid in UTF-8\n</span>}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Invalid UTF-8 in a str</span></code></pre></div>\n<p>Other <code>Arc</code> pointers to the same allocation must be to the exact same type, including lifetimes.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = Arc::new(<span class=\"string\">\"Hello, world!\"</span>);\n{\n    <span class=\"kw\">let </span>s = String::from(<span class=\"string\">\"Oh, no!\"</span>);\n    <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>y: Arc&lt;<span class=\"kw-2\">&amp;</span>str&gt; = x.clone().into();\n    <span class=\"kw\">unsafe </span>{\n        <span class=\"comment\">// this is Undefined Behavior, because x's inner type\n        // is &amp;'long str, not &amp;'short str\n        </span><span class=\"kw-2\">*</span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>y) = <span class=\"kw-2\">&amp;</span>s;\n    }\n}\n<span class=\"macro\">println!</span>(<span class=\"string\">\"{}\"</span>, <span class=\"kw-2\">&amp;*</span>x); <span class=\"comment\">// Use-after-free</span></code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#685\">source</a><a href=\"#impl-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.allocator\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#693\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.allocator\" class=\"fn\">allocator</a>(this: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;A</a></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Returns a reference to the underlying allocator.</p>\n<p>Note: this is an associated function, which means that you have\nto call it as <code>Arc::allocator(&amp;a)</code> instead of <code>a.allocator()</code>. This\nis so that there is no conflict with a method on the inner type.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#711\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_in\" class=\"fn\">new_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T&gt;</code> in the provided allocator.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::new_in(<span class=\"number\">5</span>, System);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#753\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_uninit_in\" class=\"fn\">new_uninit_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents in the provided allocator.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(get_mut_unchecked)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_uninit_in(System);\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#792\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.new_zeroed_in\" class=\"fn\">new_zeroed_in</a>(alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit)]\n#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::new_zeroed_in(System);\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>)</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#810-812\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.pin_in\" class=\"fn\">pin_in</a>(data: T, alloc: A) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator. If <code>T</code> does not implement <code>Unpin</code>,\nthen <code>data</code> will be pinned in memory and unable to be moved.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_pin_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#821-823\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_pin_in\" class=\"fn\">try_pin_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html\" title=\"struct core::pin::Pin\">Pin</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;<div class=\"where\">where\n    A: 'static,</div></h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Pin&lt;Arc&lt;T, A&gt;&gt;</code> in the provided allocator, return an error if allocation\nfails.</p>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#844\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_in\" class=\"fn\">try_new_in</a>(data: T, alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc&lt;T, A&gt;</code> in the provided allocator, returning an error if allocation fails.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>five = Arc::try_new_in(<span class=\"number\">5</span>, System)<span class=\"question-mark\">?</span>;</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_uninit_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#886\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_uninit_in\" class=\"fn\">try_new_uninit_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, in the provided allocator, returning an\nerror if allocation fails.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n#![feature(get_mut_unchecked)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span><span class=\"kw-2\">mut </span>five = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_uninit_in(System)<span class=\"question-mark\">?</span>;\n\n<span class=\"kw\">let </span>five = <span class=\"kw\">unsafe </span>{\n    <span class=\"comment\">// Deferred initialization:\n    </span>Arc::get_mut_unchecked(<span class=\"kw-2\">&amp;mut </span>five).as_mut_ptr().write(<span class=\"number\">5</span>);\n\n    five.assume_init()\n};\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>five, <span class=\"number\">5</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_new_zeroed_in\" class=\"method\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#925\">source</a><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_new_zeroed_in\" class=\"fn\">try_new_zeroed_in</a>(alloc: A) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;<a class=\"union\" href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html\" title=\"union core::mem::maybe_uninit::MaybeUninit\">MaybeUninit</a>&lt;T&gt;, A&gt;, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/alloc/struct.AllocError.html\" title=\"struct core::alloc::AllocError\">AllocError</a>&gt;</h4></section><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>allocator_api</code>)</span></div></span></summary><div class=\"docblock\"><p>Constructs a new <code>Arc</code> with uninitialized contents, with the memory\nbeing filled with <code>0</code> bytes, in the provided allocator, returning an error if allocation\nfails.</p>\n<p>See <a href=\"https://doc.rust-lang.org/nightly/core/mem/maybe_uninit/union.MaybeUninit.html#method.zeroed\" title=\"associated function core::mem::maybe_uninit::MaybeUninit::zeroed\"><code>MaybeUninit::zeroed</code></a> for examples of correct and incorrect usage\nof this method.</p>\n<h5 id=\"examples-5\"><a class=\"doc-anchor\" href=\"#examples-5\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"attr\">#![feature(new_uninit, allocator_api)]\n\n</span><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::alloc::System;\n\n<span class=\"kw\">let </span>zero = Arc::&lt;u32, <span class=\"kw\">_</span>&gt;::try_new_zeroed_in(System)<span class=\"question-mark\">?</span>;\n<span class=\"kw\">let </span>zero = <span class=\"kw\">unsafe </span>{ zero.assume_init() };\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>zero, <span class=\"number\">0</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.try_unwrap\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.4.0\">1.4.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#969\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.try_unwrap\" class=\"fn\">try_unwrap</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;T, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, an <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> is returned with the same <code>Arc</code> that was\npassed in.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>It is strongly recommended to use <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.into_inner\" title=\"associated function alloc::sync::Arc::into_inner\"><code>Arc::into_inner</code></a> instead if you don’t\nwant to keep the <code>Arc</code> in the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> case.\nImmediately dropping the <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#variant.Err\" title=\"variant core::result::Result::Err\"><code>Err</code></a> payload, like in the expression\n<code>Arc::try_unwrap(this).ok()</code>, can still cause the strong count to\ndrop to zero and the inner value of the <code>Arc</code> to be dropped:\nFor instance if two threads each execute this expression in parallel, then\nthere is a race condition. The threads could first both check whether they\nhave the last clone of their <code>Arc</code> via <code>Arc::try_unwrap</code>, and then\nboth drop their <code>Arc</code> in the call to <a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\"><code>ok</code></a>,\ntaking the strong count from two down to zero.</p>\n<h5 id=\"examples-6\"><a class=\"doc-anchor\" href=\"#examples-6\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"macro\">assert_eq!</span>(Arc::try_unwrap(x), <span class=\"prelude-val\">Ok</span>(<span class=\"number\">3</span>));\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">4</span>);\n<span class=\"kw\">let </span>_y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>Arc::try_unwrap(x).unwrap_err(), <span class=\"number\">4</span>);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.into_inner\" class=\"method\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.70.0\">1.70.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#1086\">source</a></span><h4 class=\"code-header\">pub fn <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#tymethod.into_inner\" class=\"fn\">into_inner</a>(this: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Returns the inner value, if the <code>Arc</code> has exactly one strong reference.</p>\n<p>Otherwise, <a href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html#variant.None\" title=\"variant core::option::Option::None\"><code>None</code></a> is returned and the <code>Arc</code> is dropped.</p>\n<p>This will succeed even if there are outstanding weak references.</p>\n<p>If <code>Arc::into_inner</code> is called on every clone of this <code>Arc</code>,\nit is guaranteed that exactly one of the calls returns the inner value.\nThis means in particular that the inner value is not dropped.</p>\n<p><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a> is conceptually similar to <code>Arc::into_inner</code>, but it\nis meant for different use-cases. If used as a direct replacement\nfor <code>Arc::into_inner</code> anyway, such as with the expression\n<code><a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\">Arc::try_unwrap</a>(this).<a href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html#method.ok\" title=\"method core::result::Result::ok\">ok</a>()</code>, then it does\n<strong>not</strong> give the same guarantee as described in the previous paragraph.\nFor more information, see the examples below and read the documentation\nof <a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html#method.try_unwrap\" title=\"associated function alloc::sync::Arc::try_unwrap\"><code>Arc::try_unwrap</code></a>.</p>\n<h5 id=\"examples-7\"><a class=\"doc-anchor\" href=\"#examples-7\">§</a>Examples</h5>\n<p>Minimal example demonstrating the guarantee that <code>Arc::into_inner</code> gives.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x = Arc::new(<span class=\"number\">3</span>);\n<span class=\"kw\">let </span>y = Arc::clone(<span class=\"kw-2\">&amp;</span>x);\n\n<span class=\"comment\">// Two threads calling `Arc::into_inner` on both clones of an `Arc`:\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| Arc::into_inner(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| Arc::into_inner(y));\n\n<span class=\"kw\">let </span>x_inner_value = x_thread.join().unwrap();\n<span class=\"kw\">let </span>y_inner_value = y_thread.join().unwrap();\n\n<span class=\"comment\">// One of the threads is guaranteed to receive the inner value:\n</span><span class=\"macro\">assert!</span>(<span class=\"macro\">matches!</span>(\n    (x_inner_value, y_inner_value),\n    (<span class=\"prelude-val\">None</span>, <span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>)) | (<span class=\"prelude-val\">Some</span>(<span class=\"number\">3</span>), <span class=\"prelude-val\">None</span>)\n));\n<span class=\"comment\">// The result could also be `(None, None)` if the threads called\n// `Arc::try_unwrap(x).ok()` and `Arc::try_unwrap(y).ok()` instead.</span></code></pre></div>\n<p>A more practical example demonstrating the need for <code>Arc::into_inner</code>:</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"comment\">// Definition of a simple singly linked list using `Arc`:\n</span><span class=\"attr\">#[derive(Clone)]\n</span><span class=\"kw\">struct </span>LinkedList&lt;T&gt;(<span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n<span class=\"kw\">struct </span>Node&lt;T&gt;(T, <span class=\"prelude-ty\">Option</span>&lt;Arc&lt;Node&lt;T&gt;&gt;&gt;);\n\n<span class=\"comment\">// Dropping a long `LinkedList&lt;T&gt;` relying on the destructor of `Arc`\n// can cause a stack overflow. To prevent this, we can provide a\n// manual `Drop` implementation that does the destruction in a loop:\n</span><span class=\"kw\">impl</span>&lt;T&gt; Drop <span class=\"kw\">for </span>LinkedList&lt;T&gt; {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"kw\">let </span><span class=\"kw-2\">mut </span>link = <span class=\"self\">self</span>.<span class=\"number\">0</span>.take();\n        <span class=\"kw\">while let </span><span class=\"prelude-val\">Some</span>(arc_node) = link.take() {\n            <span class=\"kw\">if let </span><span class=\"prelude-val\">Some</span>(Node(_value, next)) = Arc::into_inner(arc_node) {\n                link = next;\n            }\n        }\n    }\n}\n\n<span class=\"comment\">// Implementation of `new` and `push` omitted\n</span><span class=\"kw\">impl</span>&lt;T&gt; LinkedList&lt;T&gt; {\n    <span class=\"comment\">/* ... */\n</span>}\n\n<span class=\"comment\">// The following code could have still caused a stack overflow\n// despite the manual `Drop` impl if that `Drop` impl had used\n// `Arc::try_unwrap(arc).ok()` instead of `Arc::into_inner(arc)`.\n\n// Create a long list and clone it\n</span><span class=\"kw\">let </span><span class=\"kw-2\">mut </span>x = LinkedList::new();\n<span class=\"kw\">let </span>size = <span class=\"number\">100000</span>;\n<span class=\"kw\">for </span>i <span class=\"kw\">in </span><span class=\"number\">0</span>..size {\n    x.push(i); <span class=\"comment\">// Adds i to the front of x\n</span>}\n<span class=\"kw\">let </span>y = x.clone();\n\n<span class=\"comment\">// Drop the clones in parallel\n</span><span class=\"kw\">let </span>x_thread = std::thread::spawn(|| drop(x));\n<span class=\"kw\">let </span>y_thread = std::thread::spawn(|| drop(y));\nx_thread.join().unwrap();\ny_thread.join().unwrap();</code></pre></div>\n</div></details></div></details>",0,"parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.64.0\">1.64.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#407\">source</a></span><a href=\"#impl-AsFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html\" title=\"trait std::os::fd::owned::AsFd\">AsFd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">trait </span>MyTrait: AsFd {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/owned.rs.html#409\">source</a><a href=\"#method.as_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\" class=\"fn\">as_fd</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/struct.BorrowedFd.html\" title=\"struct std::os::fd::owned::BorrowedFd\">BorrowedFd</a>&lt;'_&gt;</h4></section></summary><div class='docblock'>Borrows the file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/owned/trait.AsFd.html#tymethod.as_fd\">Read more</a></div></details></div></details>","AsFd","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRawFd-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.63.0\">1.63.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#253\">source</a></span><a href=\"#impl-AsRawFd-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html\" title=\"trait std::os::fd::raw::AsRawFd\">AsRawFd</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl allows implementing traits that require <code>AsRawFd</code> on Arc.</p>\n\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::net::UdpSocket;\n<span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">trait </span>MyTrait: AsRawFd {\n}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Arc&lt;UdpSocket&gt; {}\n<span class=\"kw\">impl </span>MyTrait <span class=\"kw\">for </span>Box&lt;UdpSocket&gt; {}</code></pre></div>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_raw_fd\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/std/os/fd/raw.rs.html#255\">source</a><a href=\"#method.as_raw_fd\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\" class=\"fn\">as_raw_fd</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.i32.html\">i32</a></h4></section></summary><div class='docblock'>Extracts the raw file descriptor. <a href=\"https://doc.rust-lang.org/nightly/std/os/fd/raw/trait.AsRawFd.html#tymethod.as_raw_fd\">Read more</a></div></details></div></details>","AsRawFd","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.5.0\">1.5.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3780\">source</a></span><a href=\"#impl-AsRef%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html\" title=\"trait core::convert::AsRef\">AsRef</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.as_ref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3781\">source</a><a href=\"#method.as_ref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.AsRef.html#tymethod.as_ref\" class=\"fn\">as_ref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Converts this type into a shared reference of the (usually inferred) input type.</div></details></div></details>","AsRef<T>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3773\">source</a></span><a href=\"#impl-Borrow%3CT%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html\" title=\"trait core::borrow::Borrow\">Borrow</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.borrow\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3774\">source</a><a href=\"#method.borrow\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\" class=\"fn\">borrow</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href=\"https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow\">Read more</a></div></details></div></details>","Borrow<T>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Clone-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2083\">source</a></span><a href=\"#impl-Clone-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html\" title=\"trait core::clone::Clone\">Clone</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2099\">source</a><a href=\"#method.clone\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone\" class=\"fn\">clone</a>(&amp;self) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Makes a clone of the <code>Arc</code> pointer.</p>\n<p>This creates another pointer to the same allocation, increasing the\nstrong reference count.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"kw\">let _ </span>= Arc::clone(<span class=\"kw-2\">&amp;</span>five);</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clone_from\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/clone.rs.html#169\">source</a></span><a href=\"#method.clone_from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\" class=\"fn\">clone_from</a>(&amp;mut self, source: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href=\"https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from\">Read more</a></div></details></div></details>","Clone","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Debug-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3356\">source</a></span><a href=\"#impl-Debug-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html\" title=\"trait core::fmt::Debug\">Debug</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3357\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt\">Read more</a></div></details></div></details>","Debug","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Default-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3371\">source</a></span><a href=\"#impl-Default-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html\" title=\"trait core::default::Default\">Default</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.default\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3382\">source</a><a href=\"#method.default\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default\" class=\"fn\">default</a>() -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Creates a new <code>Arc&lt;T&gt;</code>, with the <code>Default</code> value for <code>T</code>.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>x: Arc&lt;i32&gt; = Default::default();\n<span class=\"macro\">assert_eq!</span>(<span class=\"kw-2\">*</span>x, <span class=\"number\">0</span>);</code></pre></div>\n</div></details></div></details>","Default","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deref-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2137\">source</a></span><a href=\"#impl-Deref-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html\" title=\"trait core::ops::deref::Deref\">Deref</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle\" open><summary><section id=\"associatedtype.Target\" class=\"associatedtype trait-impl\"><a href=\"#associatedtype.Target\" class=\"anchor\">§</a><h4 class=\"code-header\">type <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#associatedtype.Target\" class=\"associatedtype\">Target</a> = T</h4></section></summary><div class='docblock'>The resulting type after dereferencing.</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.deref\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2141\">source</a><a href=\"#method.deref\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.Deref.html#tymethod.deref\" class=\"fn\">deref</a>(&amp;self) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;T</a></h4></section></summary><div class='docblock'>Dereferences the value.</div></details></div></details>","Deref","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#impl-Deserialize%3C'de%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'de, T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T&gt;: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html\" title=\"trait serde::de::Deserialize\">Deserialize</a>&lt;'de&gt;,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Deserializing a data structure containing <code>Arc</code> will not attempt to\ndeduplicate <code>Arc</code> references to the same data. Every deserialized <code>Arc</code>\nwill end up with a strong count of 1.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.deserialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/de/impls.rs.html#2101-2112\">source</a><a href=\"#method.deserialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\" class=\"fn\">deserialize</a>&lt;D&gt;(\n    deserializer: D\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;, &lt;D as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html#associatedtype.Error\" title=\"type serde::de::Deserializer::Error\">Error</a>&gt;<div class=\"where\">where\n    D: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserializer.html\" title=\"trait serde::de::Deserializer\">Deserializer</a>&lt;'de&gt;,</div></h4></section></summary><div class='docblock'>Deserialize this value from the given Serde deserializer. <a href=\"https://docs.rs/serde/1.0.203/serde/de/trait.Deserialize.html#tymethod.deserialize\">Read more</a></div></details></div></details>","Deserialize<'de>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Display-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3349\">source</a></span><a href=\"#impl-Display-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html\" title=\"trait core::fmt::Display\">Display</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3350\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Display.html#tymethod.fmt\">Read more</a></div></details></div></details>","Display","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Drop-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2434\">source</a></span><a href=\"#impl-Drop-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html\" title=\"trait core::ops::drop::Drop\">Drop</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.drop\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2461\">source</a><a href=\"#method.drop\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/ops/drop/trait.Drop.html#tymethod.drop\" class=\"fn\">drop</a>(&amp;mut self)</h4></section></summary><div class=\"docblock\"><p>Drops the <code>Arc</code>.</p>\n<p>This will decrement the strong reference count. If the strong reference\ncount reaches zero then the only other references (if any) are\n<a href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Weak.html\" title=\"struct alloc::sync::Weak\"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">struct </span>Foo;\n\n<span class=\"kw\">impl </span>Drop <span class=\"kw\">for </span>Foo {\n    <span class=\"kw\">fn </span>drop(<span class=\"kw-2\">&amp;mut </span><span class=\"self\">self</span>) {\n        <span class=\"macro\">println!</span>(<span class=\"string\">\"dropped!\"</span>);\n    }\n}\n\n<span class=\"kw\">let </span>foo  = Arc::new(Foo);\n<span class=\"kw\">let </span>foo2 = Arc::clone(<span class=\"kw-2\">&amp;</span>foo);\n\ndrop(foo);    <span class=\"comment\">// Doesn't print anything\n</span>drop(foo2);   <span class=\"comment\">// Prints \"dropped!\"</span></code></pre></div>\n</div></details></div></details>","Drop","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Error-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.52.0\">1.52.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3812\">source</a></span><a href=\"#impl-Error-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.description\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3814\">source</a><a href=\"#method.description\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\" class=\"fn\">description</a>(&amp;self) -&gt; &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.str.html\">str</a></h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.42.0: use the Display impl or to_string()</span></div></span><div class='docblock'> <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.description\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.cause\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3819\">source</a><a href=\"#method.cause\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.cause\" class=\"fn\">cause</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a>&gt;</h4></section></summary><span class=\"item-info\"><div class=\"stab deprecated\"><span class=\"emoji\">👎</span><span>Deprecated since 1.33.0: replaced by Error::source, which can support downcasting</span></div></span></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.source\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3823\">source</a><a href=\"#method.source\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\" class=\"fn\">source</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;&amp;(dyn <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html\" title=\"trait core::error::Error\">Error</a> + 'static)&gt;</h4></section></summary><div class='docblock'>The lower-level source of this error, if any. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.source\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.provide\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3827\">source</a><a href=\"#method.provide\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\" class=\"fn\">provide</a>&lt;'a&gt;(&amp;'a self, req: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/error/struct.Request.html\" title=\"struct core::error::Request\">Request</a>&lt;'a&gt;)</h4></section></summary><span class=\"item-info\"><div class=\"stab unstable\"><span class=\"emoji\">🔬</span><span>This is a nightly-only experimental API. (<code>error_generic_member_access</code>)</span></div></span><div class='docblock'>Provides type based access to context intended for error reports. <a href=\"https://doc.rust-lang.org/nightly/core/error/trait.Error.html#method.provide\">Read more</a></div></details></div></details>","Error","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3579\">source</a></span><a href=\"#impl-From%3CBox%3CT,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3591\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(v: <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/boxed/struct.Box.html\" title=\"struct alloc::boxed::Box\">Box</a>&lt;T, A&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;</h4></section></summary><div class=\"docblock\"><p>Move a boxed object to a new, reference-counted allocation.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>unique: Box&lt;str&gt; = Box::from(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(unique);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Box<T, A>>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.45.0\">1.45.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3627-3630\">source</a></span><a href=\"#impl-From%3CCow%3C'a,+B%3E%3E-for-Arc%3CB%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;'a, B&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;<div class=\"where\">where\n    B: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;'a B</a>&gt; + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;&lt;B as <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html\" title=\"trait alloc::borrow::ToOwned\">ToOwned</a>&gt;::<a class=\"associatedtype\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned\" title=\"type alloc::borrow::ToOwned::Owned\">Owned</a>&gt;,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3645\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(cow: <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/alloc/borrow/enum.Cow.html\" title=\"enum alloc::borrow::Cow\">Cow</a>&lt;'a, B&gt;) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;B&gt;</h4></section></summary><div class=\"docblock\"><p>Create an atomically reference-counted pointer from\na clone-on-write pointer by copying its content.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>cow: Cow&lt;<span class=\"lifetime\">'_</span>, str&gt; = Cow::Borrowed(<span class=\"string\">\"eggplant\"</span>);\n<span class=\"kw\">let </span>shared: Arc&lt;str&gt; = Arc::from(cow);\n<span class=\"macro\">assert_eq!</span>(<span class=\"string\">\"eggplant\"</span>, <span class=\"kw-2\">&amp;</span>shared[..]);</code></pre></div>\n</div></details></div></details>","From<Cow<'a, B>>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.6.0\">1.6.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3479\">source</a></span><a href=\"#impl-From%3CT%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html\" title=\"trait core::convert::From\">From</a>&lt;T&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.from\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3494\">source</a><a href=\"#method.from\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from\" class=\"fn\">from</a>(t: T) -&gt; <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;</h4></section></summary><div class=\"docblock\"><p>Converts a <code>T</code> into an <code>Arc&lt;T&gt;</code></p>\n<p>The conversion moves the value into a\nnewly allocated <code>Arc</code>. It is equivalent to\ncalling <code>Arc::new(t)</code>.</p>\n<h5 id=\"example\"><a class=\"doc-anchor\" href=\"#example\">§</a>Example</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">let </span>x = <span class=\"number\">5</span>;\n<span class=\"kw\">let </span>arc = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Arc::from(x), arc);</code></pre></div>\n</div></details></div></details>","From<T>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Hash-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3471\">source</a></span><a href=\"#impl-Hash-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html\" title=\"trait core::hash::Hash\">Hash</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3472\">source</a><a href=\"#method.hash\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\" class=\"fn\">hash</a>&lt;H&gt;(&amp;self, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,</div></h4></section></summary><div class='docblock'>Feeds this value into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.hash_slice\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.3.0\">1.3.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#238-240\">source</a></span><a href=\"#method.hash_slice\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\" class=\"fn\">hash_slice</a>&lt;H&gt;(data: &amp;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.slice.html\">[Self]</a>, state: <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.reference.html\">&amp;mut H</a>)<div class=\"where\">where\n    H: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\">Hasher</a>,\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Feeds a slice of this type into the given <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html\" title=\"trait core::hash::Hasher\"><code>Hasher</code></a>. <a href=\"https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice\">Read more</a></div></details></div></details>","Hash","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-LocalSpawn-for-Arc%3CSp%3E\" class=\"impl\"><a href=\"#impl-LocalSpawn-for-Arc%3CSp%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;Sp&gt; LocalSpawn for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;Sp&gt;<div class=\"where\">where\n    Sp: LocalSpawn + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.spawn_local_obj\" class=\"method trait-impl\"><a href=\"#method.spawn_local_obj\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">spawn_local_obj</a>(\n    &amp;self,\n    future: LocalFutureObj&lt;'static, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>&gt;\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Spawns a future that will be run to completion. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.status_local\" class=\"method trait-impl\"><a href=\"#method.status_local\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">status_local</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Determines whether the executor is able to spawn new tasks. <a>Read more</a></div></details></div></details>","LocalSpawn","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Ord-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3326\">source</a></span><a href=\"#impl-Ord-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html\" title=\"trait core::cmp::Ord\">Ord</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3341\">source</a><a href=\"#method.cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp\" class=\"fn\">cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a></h4></section></summary><div class=\"docblock\"><p>Comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(Ordering::Less, five.cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.max\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#856-858\">source</a></span><a href=\"#method.max\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\" class=\"fn\">max</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the maximum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.min\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.21.0\">1.21.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#877-879\">source</a></span><a href=\"#method.min\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\" class=\"fn\">min</a>(self, other: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h4></section></summary><div class='docblock'>Compares and returns the minimum of two values. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min\">Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.clamp\" class=\"method trait-impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.50.0\">1.50.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#903-906\">source</a></span><a href=\"#method.clamp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\" class=\"fn\">clamp</a>(self, min: Self, max: Self) -&gt; Self<div class=\"where\">where\n    Self: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a>,</div></h4></section></summary><div class='docblock'>Restrict a value to a certain interval. <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp\">Read more</a></div></details></div></details>","Ord","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3192\">source</a></span><a href=\"#impl-PartialEq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html\" title=\"trait core::cmp::PartialEq\">PartialEq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.eq\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3211\">source</a><a href=\"#method.eq\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq\" class=\"fn\">eq</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Equality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are equal if their inner values are equal, even if they are\nstored in different allocation.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same allocation are always equal.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five == Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ne\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3232\">source</a><a href=\"#method.ne\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne\" class=\"fn\">ne</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Inequality for two <code>Arc</code>s.</p>\n<p>Two <code>Arc</code>s are not equal if their inner values are not equal.</p>\n<p>If <code>T</code> also implements <code>Eq</code> (implying reflexivity of equality),\ntwo <code>Arc</code>s that point to the same value are always equal.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five != Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details></div></details>","PartialEq","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3238\">source</a></span><a href=\"#impl-PartialOrd-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html\" title=\"trait core::cmp::PartialOrd\">PartialOrd</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.partial_cmp\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3253\">source</a><a href=\"#method.partial_cmp\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp\" class=\"fn\">partial_cmp</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/option/enum.Option.html\" title=\"enum core::option::Option\">Option</a>&lt;<a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html\" title=\"enum core::cmp::Ordering\">Ordering</a>&gt;</h4></section></summary><div class=\"docblock\"><p>Partial comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>\n<h5 id=\"examples\"><a class=\"doc-anchor\" href=\"#examples\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n<span class=\"kw\">use </span>std::cmp::Ordering;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert_eq!</span>(<span class=\"prelude-val\">Some</span>(Ordering::Less), five.partial_cmp(<span class=\"kw-2\">&amp;</span>Arc::new(<span class=\"number\">6</span>)));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.lt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3270\">source</a><a href=\"#method.lt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt\" class=\"fn\">lt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Less-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;</code> on their inner values.</p>\n<h5 id=\"examples-1\"><a class=\"doc-anchor\" href=\"#examples-1\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt; Arc::new(<span class=\"number\">6</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.le\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3287\">source</a><a href=\"#method.le\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le\" class=\"fn\">le</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Less than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&lt;=</code> on their inner values.</p>\n<h5 id=\"examples-2\"><a class=\"doc-anchor\" href=\"#examples-2\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &lt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.gt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3304\">source</a><a href=\"#method.gt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt\" class=\"fn\">gt</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>Greater-than comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;</code> on their inner values.</p>\n<h5 id=\"examples-3\"><a class=\"doc-anchor\" href=\"#examples-3\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt; Arc::new(<span class=\"number\">4</span>));</code></pre></div>\n</div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.ge\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3321\">source</a><a href=\"#method.ge\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge\" class=\"fn\">ge</a>(&amp;self, other: &amp;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.bool.html\">bool</a></h4></section></summary><div class=\"docblock\"><p>‘Greater than or equal to’ comparison for two <code>Arc</code>s.</p>\n<p>The two are compared by calling <code>&gt;=</code> on their inner values.</p>\n<h5 id=\"examples-4\"><a class=\"doc-anchor\" href=\"#examples-4\">§</a>Examples</h5>\n<div class=\"example-wrap\"><pre class=\"rust rust-example-rendered\"><code><span class=\"kw\">use </span>std::sync::Arc;\n\n<span class=\"kw\">let </span>five = Arc::new(<span class=\"number\">5</span>);\n\n<span class=\"macro\">assert!</span>(five &gt;= Arc::new(<span class=\"number\">5</span>));</code></pre></div>\n</div></details></div></details>","PartialOrd","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Pointer-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3363\">source</a></span><a href=\"#impl-Pointer-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html\" title=\"trait core::fmt::Pointer\">Pointer</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.fmt\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3364\">source</a><a href=\"#method.fmt\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\" class=\"fn\">fmt</a>(&amp;self, f: &amp;mut <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html\" title=\"struct core::fmt::Formatter\">Formatter</a>&lt;'_&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/core/fmt/struct.Error.html\" title=\"struct core::fmt::Error\">Error</a>&gt;</h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href=\"https://doc.rust-lang.org/nightly/core/fmt/trait.Pointer.html#tymethod.fmt\">Read more</a></div></details></div></details>","Pointer","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Serialize-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#impl-Serialize-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T&gt; <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html\" title=\"trait serde::ser::Serialize\">Serialize</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"docblock\"><p>This impl requires the <a href=\"https://serde.rs/feature-flags.html#-features-rc\"><code>&quot;rc&quot;</code></a> Cargo feature of Serde.</p>\n<p>Serializing a data structure containing <code>Arc</code> will serialize a copy of\nthe contents of the <code>Arc</code> each time the <code>Arc</code> is referenced within the\ndata structure. Serialization will not attempt to deduplicate these\nrepeated data.</p>\n</div><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.serialize\" class=\"method trait-impl\"><a class=\"src rightside\" href=\"https://docs.rs/serde/1.0.203/src/serde/ser/impls.rs.html#555-567\">source</a><a href=\"#method.serialize\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\" class=\"fn\">serialize</a>&lt;S&gt;(\n    &amp;self,\n    serializer: S\n) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;&lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Ok\" title=\"type serde::ser::Serializer::Ok\">Ok</a>, &lt;S as <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>&gt;::<a class=\"associatedtype\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html#associatedtype.Error\" title=\"type serde::ser::Serializer::Error\">Error</a>&gt;<div class=\"where\">where\n    S: <a class=\"trait\" href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serializer.html\" title=\"trait serde::ser::Serializer\">Serializer</a>,</div></h4></section></summary><div class='docblock'>Serialize this value into the given Serde serializer. <a href=\"https://docs.rs/serde/1.0.203/serde/ser/trait.Serialize.html#tymethod.serialize\">Read more</a></div></details></div></details>","Serialize","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<details class=\"toggle implementors-toggle\" open><summary><section id=\"impl-Spawn-for-Arc%3CSp%3E\" class=\"impl\"><a href=\"#impl-Spawn-for-Arc%3CSp%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;Sp&gt; Spawn for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;Sp&gt;<div class=\"where\">where\n    Sp: Spawn + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section></summary><div class=\"impl-items\"><details class=\"toggle method-toggle\" open><summary><section id=\"method.spawn_obj\" class=\"method trait-impl\"><a href=\"#method.spawn_obj\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">spawn_obj</a>(&amp;self, future: FutureObj&lt;'static, <a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>&gt;) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Spawns a future that will be run to completion. <a>Read more</a></div></details><details class=\"toggle method-toggle\" open><summary><section id=\"method.status\" class=\"method trait-impl\"><a href=\"#method.status\" class=\"anchor\">§</a><h4 class=\"code-header\">fn <a class=\"fn\">status</a>(&amp;self) -&gt; <a class=\"enum\" href=\"https://doc.rust-lang.org/nightly/core/result/enum.Result.html\" title=\"enum core::result::Result\">Result</a>&lt;<a class=\"primitive\" href=\"https://doc.rust-lang.org/nightly/std/primitive.unit.html\">()</a>, SpawnError&gt;</h4></section></summary><div class='docblock'>Determines whether the executor is able to spawn new tasks. <a>Read more</a></div></details></div></details>","Spawn","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#266\">source</a><a href=\"#impl-CoerceUnsized%3CArc%3CU,+A%3E%3E-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.CoerceUnsized.html\" title=\"trait core::ops::unsize::CoerceUnsized\">CoerceUnsized</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U, A&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","CoerceUnsized<Arc<U, A>>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#2147\">source</a><a href=\"#impl-DerefPure-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/deref/trait.DerefPure.html\" title=\"trait core::ops::deref::DerefPure\">DerefPure</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DerefPure","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"impl\"><a class=\"src rightside\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#269\">source</a><a href=\"#impl-DispatchFromDyn%3CArc%3CU%3E%3E-for-Arc%3CT%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, U&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/ops/unsize/trait.DispatchFromDyn.html\" title=\"trait core::ops::unsize::DispatchFromDyn\">DispatchFromDyn</a>&lt;<a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;U&gt;&gt; for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unsize.html\" title=\"trait core::marker::Unsize\">Unsize</a>&lt;U&gt; + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    U: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","DispatchFromDyn<Arc<U>>","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-Eq-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3346\">source</a></span><a href=\"#impl-Eq-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html\" title=\"trait core::cmp::Eq\">Eq</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,</div></h3></section>","Eq","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-Send-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#258\">source</a></span><a href=\"#impl-Send-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a>,</div></h3></section>","Send","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-Sync-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.0.0\">1.0.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#260\">source</a></span><a href=\"#impl-Sync-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Send.html\" title=\"trait core::marker::Send\">Send</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html\" title=\"trait core::marker::Sync\">Sync</a>,</div></h3></section>","Sync","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-Unpin-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.33.0\">1.33.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#3787\">source</a></span><a href=\"#impl-Unpin-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Unpin.html\" title=\"trait core::marker::Unpin\">Unpin</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a>,\n    T: ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,</div></h3></section>","Unpin","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"],["<section id=\"impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"impl\"><span class=\"rightside\"><span class=\"since\" title=\"Stable since Rust version 1.9.0\">1.9.0</span> · <a class=\"src\" href=\"https://doc.rust-lang.org/nightly/src/alloc/sync.rs.html#263\">source</a></span><a href=\"#impl-UnwindSafe-for-Arc%3CT,+A%3E\" class=\"anchor\">§</a><h3 class=\"code-header\">impl&lt;T, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a> for <a class=\"struct\" href=\"https://doc.rust-lang.org/nightly/alloc/sync/struct.Arc.html\" title=\"struct alloc::sync::Arc\">Arc</a>&lt;T, A&gt;<div class=\"where\">where\n    T: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.RefUnwindSafe.html\" title=\"trait core::panic::unwind_safe::RefUnwindSafe\">RefUnwindSafe</a> + ?<a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html\" title=\"trait core::marker::Sized\">Sized</a>,\n    A: <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/alloc/trait.Allocator.html\" title=\"trait core::alloc::Allocator\">Allocator</a> + <a class=\"trait\" href=\"https://doc.rust-lang.org/nightly/core/panic/unwind_safe/trait.UnwindSafe.html\" title=\"trait core::panic::unwind_safe::UnwindSafe\">UnwindSafe</a>,</div></h3></section>","UnwindSafe","parquet::arrow::arrow_writer::SharedColumnChunk","parquet::file::metadata::FileMetaDataPtr","parquet::file::metadata::RowGroupMetaDataPtr","parquet::file::properties::WriterPropertiesPtr","parquet::file::properties::ReaderPropertiesPtr","parquet::schema::types::TypePtr","parquet::schema::types::SchemaDescPtr","parquet::schema::types::ColumnDescPtr"]]
};if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})()