rust/tantivy
1
0
Fork 0
mirror of https://github.com/quickwit-oss/tantivy.git synced 2026-01-16 22:12:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
30b98af0663df1865508e128c450a98b43604ce5
tantivy/master/bit_vec/struct.BitVec.html
Travis CI User 63a070c832 Automatic Travis documentation build
2019-06-16 03:00:46 +00:00

378 lines
102 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

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

<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="API documentation for the Rust `BitVec` struct in crate `bit_vec`."><meta name="keywords" content="rust, rustlang, rust-lang, BitVec"><title>bit_vec::BitVec - Rust</title><link rel="stylesheet" type="text/css" href="../normalize.css"><link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../dark.css"><link rel="stylesheet" type="text/css" href="../light.css" id="themeStyle"><script src="../storage.js"></script><noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="shortcut icon" href="../favicon.ico"><style type="text/css">#crate-search{background-image:url("../down-arrow.svg");}</style></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">&#9776;</div><a href='../bit_vec/index.html'><img src='../rust-logo.png' alt='logo' width='100'></a><p class='location'>Struct BitVec</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.all">all</a><a href="#method.any">any</a><a href="#method.blocks">blocks</a><a href="#method.capacity">capacity</a><a href="#method.clear">clear</a><a href="#method.difference">difference</a><a href="#method.eq_vec">eq_vec</a><a href="#method.from_bytes">from_bytes</a><a href="#method.from_elem">from_elem</a><a href="#method.from_fn">from_fn</a><a href="#method.get">get</a><a href="#method.grow">grow</a><a href="#method.intersect">intersect</a><a href="#method.is_empty">is_empty</a><a href="#method.iter">iter</a><a href="#method.len">len</a><a href="#method.negate">negate</a><a href="#method.new">new</a><a href="#method.none">none</a><a href="#method.pop">pop</a><a href="#method.push">push</a><a href="#method.reserve">reserve</a><a href="#method.reserve_exact">reserve_exact</a><a href="#method.set">set</a><a href="#method.set_all">set_all</a><a href="#method.set_len">set_len</a><a href="#method.shrink_to_fit">shrink_to_fit</a><a href="#method.storage">storage</a><a href="#method.storage_mut">storage_mut</a><a href="#method.to_bytes">to_bytes</a><a href="#method.truncate">truncate</a><a href="#method.union">union</a><a href="#method.with_capacity">with_capacity</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-Eq">Eq</a><a href="#impl-Extend%3Cbool%3E">Extend&lt;bool&gt;</a><a href="#impl-FromIterator%3Cbool%3E">FromIterator&lt;bool&gt;</a><a href="#impl-Hash">Hash</a><a href="#impl-Index%3Cusize%3E">Index&lt;usize&gt;</a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-Ord">Ord</a><a href="#impl-PartialEq%3CBitVec%3CB%3E%3E">PartialEq&lt;BitVec&lt;B&gt;&gt;</a><a href="#impl-PartialOrd%3CBitVec%3CB%3E%3E">PartialOrd&lt;BitVec&lt;B&gt;&gt;</a></div><a class="sidebar-title" href="#synthetic-implementations">Auto Trait Implementations</a><div class="sidebar-links"><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a></div><a class="sidebar-title" href="#blanket-implementations">Blanket Implementations</a><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow">Borrow</a><a href="#impl-BorrowMut">BorrowMut</a><a href="#impl-From">From</a><a href="#impl-Into">Into</a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-TryFrom">TryFrom</a><a href="#impl-TryInto">TryInto</a></div></div><p class='location'><a href='index.html'>bit_vec</a></p><script>window.sidebarCurrent = {name: 'BitVec', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><a id="settings-menu" href="../settings.html"><img src="../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><span class='out-of-band'><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>&#x2212;</span>]</a></span><a class='srclink' href='../src/bit_vec/lib.rs.html#215-220' title='goto source code'>[src]</a></span><span class='in-band'>Struct <a href='index.html'>bit_vec</a>::<wbr><a class="struct" href=''>BitVec</a></span></h1><div class="docblock type-decl hidden-by-usual-hider"><pre class='rust struct'>pub struct BitVec&lt;B&nbsp;=&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>&gt; { /* fields omitted */ }</pre></div><div class='docblock'><p>The bitvector type.</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">10</span>, <span class="bool-val">false</span>);
<span class="comment">// insert all primes less than 10</span>
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">2</span>, <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">3</span>, <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">5</span>, <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">7</span>, <span class="bool-val">true</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">bv</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;total bits set to true: {}&quot;</span>, <span class="ident">bv</span>.<span class="ident">iter</span>().<span class="ident">filter</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">x</span>).<span class="ident">count</span>());
<span class="comment">// flip all values in bitvector, producing non-primes less than 10</span>
<span class="ident">bv</span>.<span class="ident">negate</span>();
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">bv</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;total bits set to true: {}&quot;</span>, <span class="ident">bv</span>.<span class="ident">iter</span>().<span class="ident">filter</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">x</span>).<span class="ident">count</span>());
<span class="comment">// reset bitvector to empty</span>
<span class="ident">bv</span>.<span class="ident">clear</span>();
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;{:?}&quot;</span>, <span class="ident">bv</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;total bits set to true: {}&quot;</span>, <span class="ident">bv</span>.<span class="ident">iter</span>().<span class="ident">filter</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">x</span>).<span class="ident">count</span>());</pre></div>
</div><h2 id='methods' class='small-section-header'>Methods<a href='#methods' class='anchor'></a></h2><h3 id='impl' class='impl'><code class='in-band'>impl <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u32.html">u32</a>&gt;</code><a href='#impl' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#261-381' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.new' class="method"><code id='new.v'>pub fn <a href='#method.new' class='fnname'>new</a>() -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#272-274' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates an empty <code>BitVec</code>.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">new</span>();</pre></div>
</div><h4 id='method.from_elem' class="method"><code id='from_elem.v'>pub fn <a href='#method.from_elem' class='fnname'>from_elem</a>(nbits: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, bit: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>) -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#291-299' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a <code>BitVec</code> that holds <code>nbits</code> elements, setting each element
to <code>bit</code>.</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">10</span>, <span class="bool-val">false</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">len</span>(), <span class="number">10</span>);
<span class="kw">for</span> <span class="ident">x</span> <span class="kw">in</span> <span class="ident">bv</span>.<span class="ident">iter</span>() {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="bool-val">false</span>);
}</pre></div>
</div><h4 id='method.with_capacity' class="method"><code id='with_capacity.v'>pub fn <a href='#method.with_capacity' class='fnname'>with_capacity</a>(nbits: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#309-314' title='goto source code'>[src]</a></h4><div class='docblock'><p>Constructs a new, empty <code>BitVec</code> with the specified capacity.</p>
<p>The bitvector will be able to hold at least <code>capacity</code> bits without
reallocating. If <code>capacity</code> is 0, it will not allocate.</p>
<p>It is important to note that this function does not specify the
<em>length</em> of the returned bitvector, but only the <em>capacity</em>.</p>
</div><h4 id='method.from_bytes' class="method"><code id='from_bytes.v'>pub fn <a href='#method.from_bytes' class='fnname'>from_bytes</a>(bytes: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#331-358' title='goto source code'>[src]</a></h4><div class='docblock'><p>Transforms a byte-vector into a <code>BitVec</code>. Each byte becomes eight bits,
with the most significant bits of each byte coming first. Each
bit becomes <code>true</code> if equal to 1 or <code>false</code> if equal to 0.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b10100000</span>, <span class="number">0b00010010</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">eq_vec</span>(<span class="kw-2">&amp;</span>[<span class="bool-val">true</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>, <span class="bool-val">false</span>,
<span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">false</span>,
<span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>,
<span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>, <span class="bool-val">false</span>]));</pre></div>
</div><h4 id='method.from_fn' class="method"><code id='from_fn.v'>pub fn <a href='#method.from_fn' class='fnname'>from_fn</a>&lt;F&gt;(len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, f: F) -&gt; Self <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<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>,&nbsp;</span></code><a class='srclink' href='../src/bit_vec/lib.rs.html#372-380' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a <code>BitVec</code> of the specified length where the value at each index
is <code>f(index)</code>.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_fn</span>(<span class="number">5</span>, <span class="op">|</span><span class="ident">i</span><span class="op">|</span> { <span class="ident">i</span> <span class="op">%</span> <span class="number">2</span> <span class="op">==</span> <span class="number">0</span> });
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">eq_vec</span>(<span class="kw-2">&amp;</span>[<span class="bool-val">true</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>]));</pre></div>
</div></div><h3 id='impl-1' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-1' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#383-1120' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.blocks' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="../bit_vec/struct.Blocks.html" title="struct bit_vec::Blocks">Blocks</a>&lt;'a, B&gt;</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="../bit_vec/struct.Blocks.html" title="struct bit_vec::Blocks">Blocks</a>&lt;'a, B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;'a, B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="../bit_vec/struct.Blocks.html" title="struct bit_vec::Blocks">Blocks</a>&lt;'a, B&gt;</span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = B;</span></code></div></div><code id='blocks.v'>pub fn <a href='#method.blocks' class='fnname'>blocks</a>(&amp;self) -&gt; <a class="struct" href="../bit_vec/struct.Blocks.html" title="struct bit_vec::Blocks">Blocks</a>&lt;B&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#411-414' title='goto source code'>[src]</a></h4><div class='docblock'><p>Iterator over the underlying blocks of data</p>
</div><h4 id='method.storage' class="method"><code id='storage.v'>pub fn <a href='#method.storage' class='fnname'>storage</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[B]</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#420-422' title='goto source code'>[src]</a></h4><div class='docblock'><p>Exposes the raw block storage of this BitVec</p>
<p>Only really intended for BitSet.</p>
</div><h4 id='method.storage_mut' class="method"><code id='storage_mut.v'>pub unsafe fn <a href='#method.storage_mut' class='fnname'>storage_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;B&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#428-430' title='goto source code'>[src]</a></h4><div class='docblock'><p>Exposes the raw block storage of this BitVec</p>
<p>Can probably cause unsafety. Only really intended for BitSet.</p>
</div><h4 id='method.get' class="method"><code id='get.v'>pub fn <a href='#method.get' class='fnname'>get</a>(&amp;self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</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.bool.html">bool</a>&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#461-470' title='goto source code'>[src]</a></h4><div class='docblock'><p>Retrieves the value at index <code>i</code>, or <code>None</code> if the index is out of bounds.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b01100000</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">get</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">get</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="bool-val">true</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">get</span>(<span class="number">100</span>), <span class="prelude-val">None</span>);
<span class="comment">// Can also use array indexing</span>
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>[<span class="number">1</span>], <span class="bool-val">true</span>);</pre></div>
</div><h4 id='method.set' class="method"><code id='set.v'>pub fn <a href='#method.set' class='fnname'>set</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, x: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#488-496' title='goto source code'>[src]</a></h4><div class='docblock'><p>Sets the value of a bit at an index <code>i</code>.</p>
<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
<p>Panics if <code>i</code> is out of bounds.</p>
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">5</span>, <span class="bool-val">false</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">3</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>[<span class="number">3</span>], <span class="bool-val">true</span>);</pre></div>
</div><h4 id='method.set_all' class="method"><code id='set_all.v'>pub fn <a href='#method.set_all' class='fnname'>set_all</a>(&amp;mut self)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#513-516' title='goto source code'>[src]</a></h4><div class='docblock'><p>Sets all bits to 1.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">before</span> <span class="op">=</span> <span class="number">0b01100000</span>;
<span class="kw">let</span> <span class="ident">after</span> <span class="op">=</span> <span class="number">0b11111111</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">before</span>]);
<span class="ident">bv</span>.<span class="ident">set_all</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">after</span>]));</pre></div>
</div><h4 id='method.negate' class="method"><code id='negate.v'>pub fn <a href='#method.negate' class='fnname'>negate</a>(&amp;mut self)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#533-536' title='goto source code'>[src]</a></h4><div class='docblock'><p>Flips all bits.</p>
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">before</span> <span class="op">=</span> <span class="number">0b01100000</span>;
<span class="kw">let</span> <span class="ident">after</span> <span class="op">=</span> <span class="number">0b10011111</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">before</span>]);
<span class="ident">bv</span>.<span class="ident">negate</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">after</span>]));</pre></div>
</div><h4 id='method.union' class="method"><code id='union.v'>pub fn <a href='#method.union' class='fnname'>union</a>(&amp;mut self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#564-566' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the union of two bitvectors. This acts like the bitwise <code>or</code>
function.</p>
<p>Sets <code>self</code> to the union of <code>self</code> and <code>other</code>. Both bitvectors must be
the same length. Returns <code>true</code> if <code>self</code> changed.</p>
<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
<p>Panics if the bitvectors are of different lengths.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="number">0b01100100</span>;
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="number">0b01011010</span>;
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="number">0b01111110</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">a</span>]);
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">b</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">union</span>(<span class="kw-2">&amp;</span><span class="ident">b</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">a</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">res</span>]));</pre></div>
</div><h4 id='method.intersect' class="method"><code id='intersect.v'>pub fn <a href='#method.intersect' class='fnname'>intersect</a>(&amp;mut self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#594-596' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the intersection of two bitvectors. This acts like the
bitwise <code>and</code> function.</p>
<p>Sets <code>self</code> to the intersection of <code>self</code> and <code>other</code>. Both bitvectors
must be the same length. Returns <code>true</code> if <code>self</code> changed.</p>
<h1 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h1>
<p>Panics if the bitvectors are of different lengths.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="number">0b01100100</span>;
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="number">0b01011010</span>;
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="number">0b01000000</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">a</span>]);
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">b</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">a</span>.<span class="ident">intersect</span>(<span class="kw-2">&amp;</span><span class="ident">b</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">a</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">res</span>]));</pre></div>
</div><h4 id='method.difference' class="method"><code id='difference.v'>pub fn <a href='#method.difference' class='fnname'>difference</a>(&amp;mut self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#631-633' title='goto source code'>[src]</a></h4><div class='docblock'><p>Calculates the difference between two bitvectors.</p>
<p>Sets each element of <code>self</code> to the value of that element minus the
element of <code>other</code> at the same index. Both bitvectors must be the same
length. Returns <code>true</code> if <code>self</code> changed.</p>
<h1 id="panics-3" class="section-header"><a href="#panics-3">Panics</a></h1>
<p>Panics if the bitvectors are of different length.</p>
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="number">0b01100100</span>;
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="number">0b01011010</span>;
<span class="kw">let</span> <span class="ident">a_b</span> <span class="op">=</span> <span class="number">0b00100100</span>; <span class="comment">// a - b</span>
<span class="kw">let</span> <span class="ident">b_a</span> <span class="op">=</span> <span class="number">0b00011010</span>; <span class="comment">// b - a</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bva</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">a</span>]);
<span class="kw">let</span> <span class="ident">bvb</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">b</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bva</span>.<span class="ident">difference</span>(<span class="kw-2">&amp;</span><span class="ident">bvb</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bva</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">a_b</span>]));
<span class="kw">let</span> <span class="ident">bva</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">a</span>]);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bvb</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">b</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bvb</span>.<span class="ident">difference</span>(<span class="kw-2">&amp;</span><span class="ident">bva</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bvb</span>, <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="ident">b_a</span>]));</pre></div>
</div><h4 id='method.all' class="method"><code id='all.v'>pub fn <a href='#method.all' class='fnname'>all</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#649-658' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if all bits are 1.</p>
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">5</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">all</span>(), <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">1</span>, <span class="bool-val">false</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">all</span>(), <span class="bool-val">false</span>);</pre></div>
</div><h4 id='method.iter' class="method"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;'a, B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>;</span></code></div></div><code id='iter.v'>pub fn <a href='#method.iter' class='fnname'>iter</a>(&amp;self) -&gt; <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;B&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#671-673' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns an iterator over the elements of the vector in order.</p>
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b01110100</span>, <span class="number">0b10010010</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">iter</span>().<span class="ident">filter</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="kw-2">*</span><span class="ident">x</span>).<span class="ident">count</span>(), <span class="number">7</span>);</pre></div>
</div><h4 id='method.none' class="method"><code id='none.v'>pub fn <a href='#method.none' class='fnname'>none</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#794-796' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if all bits are 0.</p>
<h1 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">10</span>, <span class="bool-val">false</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">none</span>(), <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">3</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">none</span>(), <span class="bool-val">false</span>);</pre></div>
</div><h4 id='method.any' class="method"><code id='any.v'>pub fn <a href='#method.any' class='fnname'>any</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#812-814' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if any bit is 1.</p>
<h1 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">10</span>, <span class="bool-val">false</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">any</span>(), <span class="bool-val">false</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">3</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">any</span>(), <span class="bool-val">true</span>);</pre></div>
</div><h4 id='method.to_bytes' class="method"><code id='to_bytes.v'>pub fn <a href='#method.to_bytes' class='fnname'>to_bytes</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/nightly/alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.u8.html">u8</a>&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#837-860' title='goto source code'>[src]</a></h4><div class='docblock'><p>Organises the bits into bytes, such that the first bit in the
<code>BitVec</code> becomes the high-order bit of the first byte. If the
size of the <code>BitVec</code> is not a multiple of eight then trailing bits
will be filled-in with <code>false</code>.</p>
<h1 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">3</span>, <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">1</span>, <span class="bool-val">false</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">to_bytes</span>(), [<span class="number">0b10100000</span>]);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">9</span>, <span class="bool-val">false</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">2</span>, <span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">set</span>(<span class="number">8</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">to_bytes</span>(), [<span class="number">0b00100000</span>, <span class="number">0b10000000</span>]);</pre></div>
</div><h4 id='method.eq_vec' class="method"><code id='eq_vec.v'>pub fn <a href='#method.eq_vec' class='fnname'>eq_vec</a>(&amp;self, v: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#880-883' title='goto source code'>[src]</a></h4><div class='docblock'><p>Compares a <code>BitVec</code> to a slice of <code>bool</code>s.
Both the <code>BitVec</code> and slice must have the same length.</p>
<h1 id="panics-4" class="section-header"><a href="#panics-4">Panics</a></h1>
<p>Panics if the <code>BitVec</code> and slice are of different length.</p>
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b10100000</span>]);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">eq_vec</span>(<span class="kw-2">&amp;</span>[<span class="bool-val">true</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>, <span class="bool-val">false</span>,
<span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">false</span>, <span class="bool-val">false</span>]));</pre></div>
</div><h4 id='method.truncate' class="method"><code id='truncate.v'>pub fn <a href='#method.truncate' class='fnname'>truncate</a>(&amp;mut self, len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#900-907' title='goto source code'>[src]</a></h4><div class='docblock'><p>Shortens a <code>BitVec</code>, dropping excess elements.</p>
<p>If <code>len</code> is greater than the vector's current length, this has no
effect.</p>
<h1 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b01001011</span>]);
<span class="ident">bv</span>.<span class="ident">truncate</span>(<span class="number">2</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">eq_vec</span>(<span class="kw-2">&amp;</span>[<span class="bool-val">false</span>, <span class="bool-val">true</span>]));</pre></div>
</div><h4 id='method.reserve' class="method"><code id='reserve.v'>pub fn <a href='#method.reserve' class='fnname'>reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#927-933' title='goto source code'>[src]</a></h4><div class='docblock'><p>Reserves capacity for at least <code>additional</code> more bits to be inserted in the given
<code>BitVec</code>. The collection may reserve more space to avoid frequent reallocations.</p>
<h1 id="panics-5" class="section-header"><a href="#panics-5">Panics</a></h1>
<p>Panics if the new capacity overflows <code>usize</code>.</p>
<h1 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">3</span>, <span class="bool-val">false</span>);
<span class="ident">bv</span>.<span class="ident">reserve</span>(<span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">len</span>(), <span class="number">3</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">capacity</span>() <span class="op">&gt;=</span> <span class="number">13</span>);</pre></div>
</div><h4 id='method.reserve_exact' class="method"><code id='reserve_exact.v'>pub fn <a href='#method.reserve_exact' class='fnname'>reserve_exact</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#957-963' title='goto source code'>[src]</a></h4><div class='docblock'><p>Reserves the minimum capacity for exactly <code>additional</code> more bits to be inserted in the
given <code>BitVec</code>. Does nothing if the capacity is already sufficient.</p>
<p>Note that the allocator may give the collection more space than it requests. Therefore
capacity can not be relied upon to be precisely minimal. Prefer <code>reserve</code> if future
insertions are expected.</p>
<h1 id="panics-6" class="section-header"><a href="#panics-6">Panics</a></h1>
<p>Panics if the new capacity overflows <code>usize</code>.</p>
<h1 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_elem</span>(<span class="number">3</span>, <span class="bool-val">false</span>);
<span class="ident">bv</span>.<span class="ident">reserve</span>(<span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">len</span>(), <span class="number">3</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">capacity</span>() <span class="op">&gt;=</span> <span class="number">13</span>);</pre></div>
</div><h4 id='method.capacity' class="method"><code id='capacity.v'>pub fn <a href='#method.capacity' class='fnname'>capacity</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#978-980' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the capacity in bits for this bit vector. Inserting any
element less than this amount will not trigger a resizing.</p>
<h1 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">new</span>();
<span class="ident">bv</span>.<span class="ident">reserve</span>(<span class="number">10</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">capacity</span>() <span class="op">&gt;=</span> <span class="number">10</span>);</pre></div>
</div><h4 id='method.grow' class="method"><code id='grow.v'>pub fn <a href='#method.grow' class='fnname'>grow</a>(&amp;mut self, n: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, value: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#998-1035' title='goto source code'>[src]</a></h4><div class='docblock'><p>Grows the <code>BitVec</code> in-place, adding <code>n</code> copies of <code>value</code> to the <code>BitVec</code>.</p>
<h1 id="panics-7" class="section-header"><a href="#panics-7">Panics</a></h1>
<p>Panics if the new len overflows a <code>usize</code>.</p>
<h1 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b01001011</span>]);
<span class="ident">bv</span>.<span class="ident">grow</span>(<span class="number">2</span>, <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">len</span>(), <span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">to_bytes</span>(), [<span class="number">0b01001011</span>, <span class="number">0b11000000</span>]);</pre></div>
</div><h4 id='method.pop' class="method"><code id='pop.v'>pub fn <a href='#method.pop' class='fnname'>pop</a>(&amp;mut 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="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1050-1065' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes the last bit from the BitVec, and returns it. Returns None if the BitVec is empty.</p>
<h1 id="examples-23" class="section-header"><a href="#examples-23">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">from_bytes</span>(<span class="kw-2">&amp;</span>[<span class="number">0b01001001</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="bool-val">true</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">pop</span>(), <span class="prelude-val">Some</span>(<span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">len</span>(), <span class="number">6</span>);</pre></div>
</div><h4 id='method.push' class="method"><code id='push.v'>pub fn <a href='#method.push' class='fnname'>push</a>(&amp;mut self, elem: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1080-1087' title='goto source code'>[src]</a></h4><div class='docblock'><p>Pushes a <code>bool</code> onto the end.</p>
<h1 id="examples-24" class="section-header"><a href="#examples-24">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">bit_vec</span>::<span class="ident">BitVec</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">bv</span> <span class="op">=</span> <span class="ident">BitVec</span>::<span class="ident">new</span>();
<span class="ident">bv</span>.<span class="ident">push</span>(<span class="bool-val">true</span>);
<span class="ident">bv</span>.<span class="ident">push</span>(<span class="bool-val">false</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">bv</span>.<span class="ident">eq_vec</span>(<span class="kw-2">&amp;</span>[<span class="bool-val">true</span>, <span class="bool-val">false</span>]));</pre></div>
</div><h4 id='method.len' class="method"><code id='len.v'>pub fn <a href='#method.len' class='fnname'>len</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#1091' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the total number of bits in this vector</p>
</div><h4 id='method.set_len' class="method"><code id='set_len.v'>pub unsafe fn <a href='#method.set_len' class='fnname'>set_len</a>(&amp;mut self, len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1097-1099' title='goto source code'>[src]</a></h4><div class='docblock'><p>Sets the number of bits that this BitVec considers initialized.</p>
<p>Almost certainly can cause bad stuff. Only really intended for BitSet.</p>
</div><h4 id='method.is_empty' class="method"><code id='is_empty.v'>pub fn <a href='#method.is_empty' class='fnname'>is_empty</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#1103' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns true if there are no bits in this vector</p>
</div><h4 id='method.clear' class="method"><code id='clear.v'>pub fn <a href='#method.clear' class='fnname'>clear</a>(&amp;mut self)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1107-1109' title='goto source code'>[src]</a></h4><div class='docblock'><p>Clears all bits in this vector.</p>
</div><h4 id='method.shrink_to_fit' class="method"><code id='shrink_to_fit.v'>pub fn <a href='#method.shrink_to_fit' class='fnname'>shrink_to_fit</a>(&amp;mut self)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1117-1119' title='goto source code'>[src]</a></h4><div class='docblock'><p>Shrinks the capacity of the underlying storage as much as
possible.</p>
<p>It will drop down as close as possible to the length but the
allocator may still inform the underlying storage that there
is space for a few more elements/bits.</p>
</div></div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-Debug' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Debug' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1188-1195' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method hidden"><code id='fmt.v'>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&amp;self, fmt: &amp;mut <a class="struct" href="https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>) -&gt; <a class="type" href="https://doc.rust-lang.org/nightly/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#1189-1194' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-PartialEq%3CBitVec%3CB%3E%3E' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>&lt;<a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;&gt; for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-PartialEq%3CBitVec%3CB%3E%3E' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1207-1215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq' class="method hidden"><code id='eq.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#1209-1214' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne' class="method"><code id='ne.v'><div class="docblock attributes">#[must_use]
</div>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#200' title='goto source code'>[src]</a></h4><div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-Eq' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Eq' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1217' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-Ord' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Ord' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1168-1185' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.cmp' class="method hidden"><code id='cmp.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#1170-1184' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method returns an <code>Ordering</code> between <code>self</code> and <code>other</code>. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp">Read more</a></p>
</div><h4 id='method.max' class="method"><code id='max.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.max' class='fnname'>max</a>(self, other: Self) -&gt; Self</code><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#549-552' title='goto source code'>[src]</a></h4><div class='docblock'><p>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></p>
</div><h4 id='method.min' class="method"><code id='min.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.min' class='fnname'>min</a>(self, other: Self) -&gt; Self</code><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#566-569' title='goto source code'>[src]</a></h4><div class='docblock'><p>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></p>
</div><h4 id='method.clamp' class="method"><code id='clamp.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#method.clamp' class='fnname'>clamp</a>(self, min: Self, max: Self) -&gt; Self</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#590-600' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab unstable'><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>clamp</code>)</div></div><div class='docblock'><p>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></p>
</div></div><h3 id='impl-PartialOrd%3CBitVec%3CB%3E%3E' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a>&lt;<a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;&gt; for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-PartialOrd%3CBitVec%3CB%3E%3E' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1161-1166' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.partial_cmp' class="method hidden"><code id='partial_cmp.v'>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>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="enum" href="https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a>&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1163-1165' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp">Read more</a></p>
</div><h4 id='method.lt' class="method"><code id='lt.v'><div class="docblock attributes">#[must_use]
</div>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#772-777' title='goto source code'>[src]</a></h4><div class='docblock'><p>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code>&lt;</code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt">Read more</a></p>
</div><h4 id='method.le' class="method"><code id='le.v'><div class="docblock attributes">#[must_use]
</div>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#794-799' title='goto source code'>[src]</a></h4><div class='docblock'><p>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>&lt;=</code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le">Read more</a></p>
</div><h4 id='method.gt' class="method"><code id='gt.v'><div class="docblock attributes">#[must_use]
</div>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#815-820' title='goto source code'>[src]</a></h4><div class='docblock'><p>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>&gt;</code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt">Read more</a></p>
</div><h4 id='method.ge' class="method"><code id='ge.v'><div class="docblock attributes">#[must_use]
</div>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><div class='since' title='Stable since Rust version 1.0.0'>1.0.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#837-842' title='goto source code'>[src]</a></h4><div class='docblock'><p>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>&gt;=</code> operator. <a href="https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge">Read more</a></p>
</div></div><h3 id='impl-Hash' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Hash' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1197-1205' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.hash' class="method hidden"><code id='hash.v'>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a>&lt;H:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>&gt;(&amp;self, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>H)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1199-1204' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div><h4 id='method.hash_slice' class="method"><code id='hash_slice.v'>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a>&lt;H&gt;(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>H) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;H: <a class="trait" href="https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>,&nbsp;</span></code><div class='since' title='Stable since Rust version 1.3.0'>1.3.0</div><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#193-199' title='goto source code'>[src]</a></h4><div class='docblock'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></div><h3 id='impl-Index%3Cusize%3E' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html" title="trait core::ops::index::Index">Index</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt; for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Index%3Cusize%3E' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#223-234' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output' class="type"><code id='Output.t'>type <a href='https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></h4><div class='docblock'><p>The returned type after indexing.</p>
</div><h4 id='method.index' class="method hidden"><code id='index.v'>fn <a href='https://doc.rust-lang.org/nightly/core/ops/index/trait.Index.html#tymethod.index' class='fnname'>index</a>(&amp;self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='../src/bit_vec/lib.rs.html#227-233' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the indexing (<code>container[index]</code>) operation.</p>
</div></div><h3 id='impl-Extend%3Cbool%3E' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html" title="trait core::iter::traits::collect::Extend">Extend</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>&gt; for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Extend%3Cbool%3E' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1136-1146' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.extend' class="method hidden"><code id='extend.v'>fn <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend' class='fnname'>extend</a>&lt;I:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>&gt;&gt;(&amp;mut self, iterable: I)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1138-1145' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Extends a collection with the contents of an iterator. <a href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.Extend.html#tymethod.extend">Read more</a></p>
</div></div><h3 id='impl-FromIterator%3Cbool%3E' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html" title="trait core::iter::traits::collect::FromIterator">FromIterator</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>&gt; for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-FromIterator%3Cbool%3E' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1127-1134' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from_iter' class="method hidden"><code id='from_iter.v'>fn <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter' class='fnname'>from_iter</a>&lt;I:&nbsp;<a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>&gt;&gt;(iter: I) -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1129-1133' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates a value from an iterator. <a href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter">Read more</a></p>
</div></div><h3 id='impl-IntoIterator' class='impl'><code class='in-band'>impl&lt;'a, B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &amp;'a <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-IntoIterator' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1251-1259' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item' class="type"><code id='Item.t'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter' class="type"><code id='IntoIter.t'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;'a, B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>;</span></code></div></div><code id='into_iter.v'>fn <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; <a class="struct" href="../bit_vec/struct.Iter.html" title="struct bit_vec::Iter">Iter</a>&lt;'a, B&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1256-1258' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-IntoIterator-1' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for <a class="struct" href="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-IntoIterator-1' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1285-1294' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item-1' class="type"><code id='Item.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter-1' class="type"><code id='IntoIter.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = <a class="struct" href="../bit_vec/struct.IntoIter.html" title="struct bit_vec::IntoIter">IntoIter</a>&lt;B&gt;</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter-1' class="method hidden"><div class="important-traits"><div class='tooltip'>ⓘ<span class='tooltiptext'>Important traits for <a class="struct" href="../bit_vec/struct.IntoIter.html" title="struct bit_vec::IntoIter">IntoIter</a>&lt;B&gt;</span></div><div class="content hidden"><h3 class="important">Important traits for <a class="struct" href="../bit_vec/struct.IntoIter.html" title="struct bit_vec::IntoIter">IntoIter</a>&lt;B&gt;</h3><code class="content"><span class="where fmt-newline">impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a> for <a class="struct" href="../bit_vec/struct.IntoIter.html" title="struct bit_vec::IntoIter">IntoIter</a>&lt;B&gt;</span><span class="where fmt-newline"> type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>;</span></code></div></div><code id='into_iter.v-1'>fn <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; <a class="struct" href="../bit_vec/struct.IntoIter.html" title="struct bit_vec::IntoIter">IntoIter</a>&lt;B&gt;</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1290-1293' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-Clone' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Clone' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1148-1159' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.clone' class="method hidden"><code id='clone.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&amp;self) -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1150-1152' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
</div><h4 id='method.clone_from' class="method hidden"><code id='clone_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&amp;mut self, source: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Self)</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1155-1158' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>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></p>
</div></div><h3 id='impl-Default' class='impl'><code class='in-band'>impl&lt;B:&nbsp;<a class="trait" href="../bit_vec/trait.BitBlock.html" title="trait bit_vec::BitBlock">BitBlock</a>&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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt;</code><a href='#impl-Default' class='anchor'></a><a class='srclink' href='../src/bit_vec/lib.rs.html#1122-1125' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.default' class="method hidden"><code id='default.v'>fn <a href='https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default' class='fnname'>default</a>() -&gt; Self</code><a class='srclink' href='../src/bit_vec/lib.rs.html#1124' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns the &quot;default value&quot; for a type. <a href="https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default">Read more</a></p>
</div></div></div><h2 id='synthetic-implementations' class='small-section-header'>Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a></h2><div id='synthetic-implementations-list'><h3 id='impl-Send' class='impl'><code class='in-band'>impl&lt;B&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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;B: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,&nbsp;</span></code><a href='#impl-Send' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><code class='in-band'>impl&lt;B&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="../bit_vec/struct.BitVec.html" title="struct bit_vec::BitVec">BitVec</a>&lt;B&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;B: <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,&nbsp;</span></code><a href='#impl-Sync' class='anchor'></a></h3><div class='impl-items'></div></div><h2 id='blanket-implementations' class='small-section-header'>Blanket Implementations<a href='#blanket-implementations' class='anchor'></a></h2><div id='blanket-implementations-list'><h3 id='impl-From' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a> for T</code><a href='#impl-From' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#546-548' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#547' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-IntoIterator-2' class='impl'><code class='in-band'>impl&lt;I&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for I <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a>,&nbsp;</span></code><a href='#impl-IntoIterator-2' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#241-248' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item-2' class="type"><code id='Item.t-2'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = &lt;I as <a class="trait" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a>&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item" title="type core::iter::traits::iterator::Iterator::Item">Item</a></code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter-2' class="type"><code id='IntoIter.t-2'>type <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = I</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter-2' class="method hidden"><code id='into_iter.v-2'>fn <a href='https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; I</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#245-247' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/nightly/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-TryFrom' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryFrom' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#565-571' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/nightly/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#568-570' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-TryInto' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryInto' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#553-560' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/nightly/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="https://doc.rust-lang.org/nightly/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#557-559' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Into' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/nightly/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-Into' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#537-542' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='https://doc.rust-lang.org/nightly/core/convert/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -&gt; U</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert.rs.html#539-541' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Borrow' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Borrow' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#213-215' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><code id='borrow.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#214' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></div><h3 id='impl-BorrowMut' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-BorrowMut' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#218-220' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><code id='borrow_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#219' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></div><h3 id='impl-Any' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#100-102' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id' class='fnname'>type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#101' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></div><h3 id='impl-ToOwned' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,&nbsp;</span></code><a href='#impl-ToOwned' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#80-91' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Owned' class="type"><code id='Owned.t'>type <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#associatedtype.Owned' class="type">Owned</a> = T</code></h4><h4 id='method.to_owned' class="method hidden"><code id='to_owned.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned' class='fnname'>to_owned</a>(&amp;self) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#84-86' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
</div><h4 id='method.clone_into' class="method hidden"><code id='clone_into.v'>fn <a href='https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into' class='fnname'>clone_into</a>(&amp;self, target: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#88-90' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</summary><p>recently added</p>
</details></div></div><div class='docblock hidden'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/nightly/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>&#9166;</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g., <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g., <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g., <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../";window.currentCrate = "bit_vec";</script><script src="../aliases.js"></script><script src="../main.js"></script><script defer src="../search-index.js"></script></body></html>
Reference in New Issue View Git Blame Copy Permalink