<!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 `BitSet` struct in crate `bit_set`.">
<meta name="keywords" content="rust, rustlang, rust-lang, BitSet">
<title>bit_set::BitSet - Rust</title>
<link rel="stylesheet" type="text/css" href="../rustdoc.css">
<link rel="stylesheet" type="text/css" href="../main.css">
</head>
<body class="rustdoc">
<!--[if lte IE 8]>
<div class="warning">
This old browser is unsupported and will most likely display funky
things.
</div>
<![endif]-->
<nav class="sidebar">
<p class='location'><a href='index.html'>bit_set</a></p><script>window.sidebarCurrent = {name: 'BitSet', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script>
</nav>
<nav class="sub">
<form class="search-form js-only">
<div class="search-container">
<input class="search-input" name="search"
autocomplete="off"
placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
type="search">
</div>
</form>
</nav>
<section id='main' class="content struct">
<h1 class='fqn'><span class='in-band'>Struct <a href='index.html'>bit_set</a>::<wbr><a class='struct' href=''>BitSet</a></span><span class='out-of-band'><span id='render-detail'>
<a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">
[<span class='inner'>−</span>]
</a>
</span><a id='src-26' class='srclink' href='../src/bit_set/lib.rs.html#99-101' title='goto source code'>[src]</a></span></h1>
<pre class='rust struct'>pub struct BitSet<B = <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.u32.html'>u32</a>> {
// some fields omitted
}</pre><h2 id='methods'>Methods</h2><h3 class='impl'><code>impl <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.u32.html'>u32</a>></code></h3><div class='impl-items'><h4 id='method.new' class='method'><code>fn <a href='#method.new' class='fnname'>new</a>() -> Self</code></h4>
<div class='docblock'><p>Creates a new empty <code>BitSet</code>.</p>
<h1 id='examples' class='section-header'><a href='#examples'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();</pre>
</div><h4 id='method.with_capacity' class='method'><code>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>) -> Self</code></h4>
<div class='docblock'><p>Creates a new <code>BitSet</code> with initially no contents, able to
hold <code>nbits</code> elements without resizing.</p>
<h1 id='examples-1' class='section-header'><a href='#examples-1'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>with_capacity</span>(<span class='number'>100</span>);
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>100</span>);</pre>
</div><h4 id='method.from_bit_vec' class='method'><code>fn <a href='#method.from_bit_vec' class='fnname'>from_bit_vec</a>(bit_vec: <a class='struct' href='../bit_vec/struct.BitVec.html' title='bit_vec::BitVec'>BitVec</a>) -> Self</code></h4>
<div class='docblock'><p>Creates a new <code>BitSet</code> from the given bit vector.</p>
<h1 id='examples-2' class='section-header'><a href='#examples-2'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>extern</span> <span class='kw'>crate</span> <span class='ident'>bit_vec</span>;
<span class='kw'>extern</span> <span class='kw'>crate</span> <span class='ident'>bit_set</span>;
<span class='kw'>fn</span> <span class='ident'>main</span>() {
<span class='kw'>use</span> <span class='ident'>bit_vec</span>::<span class='ident'>BitVec</span>;
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</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'>&</span>[<span class='number'>0b01100000</span>]);
<span class='kw'>let</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bit_vec</span>(<span class='ident'>bv</span>);
<span class='comment'>// Print 1, 2 in arbitrary order</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>s</span>.<span class='ident'>iter</span>() {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}
}</pre>
</div><h4 id='method.from_bytes' class='method'><code>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'>&[</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>) -> Self</code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.capacity' class='method'><code>fn <a href='#method.capacity' class='fnname'>capacity</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a></code></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-3' class='section-header'><a href='#examples-3'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>with_capacity</span>(<span class='number'>100</span>);
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>100</span>);</pre>
</div><h4 id='method.reserve_len' class='method'><code>fn <a href='#method.reserve_len' class='fnname'>reserve_len</a>(&mut self, len: <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>)</code></h4>
<div class='docblock'><p>Reserves capacity for the given <code>BitSet</code> to contain <code>len</code> distinct elements. In the case
of <code>BitSet</code> this means reallocations will not occur as long as all inserted elements
are less than <code>len</code>.</p>
<p>The collection may reserve more space to avoid frequent reallocations.</p>
<h1 id='examples-4' class='section-header'><a href='#examples-4'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();
<span class='ident'>s</span>.<span class='ident'>reserve_len</span>(<span class='number'>10</span>);
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>10</span>);</pre>
</div><h4 id='method.reserve_len_exact' class='method'><code>fn <a href='#method.reserve_len_exact' class='fnname'>reserve_len_exact</a>(&mut self, len: <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>)</code></h4>
<div class='docblock'><p>Reserves the minimum capacity for the given <code>BitSet</code> to contain <code>len</code> distinct elements.
In the case of <code>BitSet</code> this means reallocations will not occur as long as all inserted
elements are less than <code>len</code>.</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_len</code> if future
insertions are expected.</p>
<h1 id='examples-5' class='section-header'><a href='#examples-5'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();
<span class='ident'>s</span>.<span class='ident'>reserve_len_exact</span>(<span class='number'>10</span>);
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>10</span>);</pre>
</div><h4 id='method.into_bit_vec' class='method'><code>fn <a href='#method.into_bit_vec' class='fnname'>into_bit_vec</a>(self) -> <a class='struct' href='../bit_vec/struct.BitVec.html' title='bit_vec::BitVec'>BitVec</a><B></code></h4>
<div class='docblock'><p>Consumes this set to return the underlying bit vector.</p>
<h1 id='examples-6' class='section-header'><a href='#examples-6'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();
<span class='ident'>s</span>.<span class='ident'>insert</span>(<span class='number'>0</span>);
<span class='ident'>s</span>.<span class='ident'>insert</span>(<span class='number'>3</span>);
<span class='kw'>let</span> <span class='ident'>bv</span> <span class='op'>=</span> <span class='ident'>s</span>.<span class='ident'>into_bit_vec</span>();
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>bv</span>[<span class='number'>0</span>]);
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>bv</span>[<span class='number'>3</span>]);</pre>
</div><h4 id='method.get_ref' class='method'><code>fn <a href='#method.get_ref' class='fnname'>get_ref</a>(&self) -> &<a class='struct' href='../bit_vec/struct.BitVec.html' title='bit_vec::BitVec'>BitVec</a><B></code></h4>
<div class='docblock'><p>Returns a reference to the underlying bit vector.</p>
<h1 id='examples-7' class='section-header'><a href='#examples-7'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();
<span class='ident'>s</span>.<span class='ident'>insert</span>(<span class='number'>0</span>);
<span class='kw'>let</span> <span class='ident'>bv</span> <span class='op'>=</span> <span class='ident'>s</span>.<span class='ident'>get_ref</span>();
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>bv</span>[<span class='number'>0</span>], <span class='boolval'>true</span>);</pre>
</div><h4 id='method.shrink_to_fit' class='method'><code>fn <a href='#method.shrink_to_fit' class='fnname'>shrink_to_fit</a>(&mut self)</code></h4>
<div class='docblock'><p>Truncates the underlying vector to the least length required.</p>
<h1 id='examples-8' class='section-header'><a href='#examples-8'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>new</span>();
<span class='ident'>s</span>.<span class='ident'>insert</span>(<span class='number'>32183231</span>);
<span class='ident'>s</span>.<span class='ident'>remove</span>(<span class='kw-2'>&</span><span class='number'>32183231</span>);
<span class='comment'>// Internal storage will probably be bigger than necessary</span>
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"old capacity: {}"</span>, <span class='ident'>s</span>.<span class='ident'>capacity</span>());
<span class='comment'>// Now should be smaller</span>
<span class='ident'>s</span>.<span class='ident'>shrink_to_fit</span>();
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"new capacity: {}"</span>, <span class='ident'>s</span>.<span class='ident'>capacity</span>());</pre>
</div><h4 id='method.iter' class='method'><code>fn <a href='#method.iter' class='fnname'>iter</a>(&self) -> <a class='struct' href='../bit_set/struct.Iter.html' title='bit_set::Iter'>Iter</a><B></code></h4>
<div class='docblock'><p>Iterator over each usize stored in the <code>BitSet</code>.</p>
<h1 id='examples-9' class='section-header'><a href='#examples-9'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>s</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b01001010</span>]);
<span class='comment'>// Print 1, 4, 6 in arbitrary order</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>s</span>.<span class='ident'>iter</span>() {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}</pre>
</div><h4 id='method.union' class='method'><code>fn <a href='#method.union' class='fnname'>union</a><'a>(&'a self, other: &'a Self) -> <a class='struct' href='../bit_set/struct.Union.html' title='bit_set::Union'>Union</a><'a, B></code></h4>
<div class='docblock'><p>Iterator over each usize stored in <code>self</code> union <code>other</code>.
See <a href="#method.union_with">union_with</a> for an efficient in-place version.</p>
<h1 id='examples-10' class='section-header'><a href='#examples-10'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b01101000</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b10100000</span>]);
<span class='comment'>// Print 0, 1, 2, 4 in arbitrary order</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>a</span>.<span class='ident'>union</span>(<span class='kw-2'>&</span><span class='ident'>b</span>) {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}</pre>
</div><h4 id='method.intersection' class='method'><code>fn <a href='#method.intersection' class='fnname'>intersection</a><'a>(&'a self, other: &'a Self) -> <a class='struct' href='../bit_set/struct.Intersection.html' title='bit_set::Intersection'>Intersection</a><'a, B></code></h4>
<div class='docblock'><p>Iterator over each usize stored in <code>self</code> intersect <code>other</code>.
See <a href="#method.intersect_with">intersect_with</a> for an efficient in-place version.</p>
<h1 id='examples-11' class='section-header'><a href='#examples-11'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b01101000</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b10100000</span>]);
<span class='comment'>// Print 2</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>a</span>.<span class='ident'>intersection</span>(<span class='kw-2'>&</span><span class='ident'>b</span>) {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}</pre>
</div><h4 id='method.difference' class='method'><code>fn <a href='#method.difference' class='fnname'>difference</a><'a>(&'a self, other: &'a Self) -> <a class='struct' href='../bit_set/struct.Difference.html' title='bit_set::Difference'>Difference</a><'a, B></code></h4>
<div class='docblock'><p>Iterator over each usize stored in the <code>self</code> setminus <code>other</code>.
See <a href="#method.difference_with">difference_with</a> for an efficient in-place version.</p>
<h1 id='examples-12' class='section-header'><a href='#examples-12'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b01101000</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b10100000</span>]);
<span class='comment'>// Print 1, 4 in arbitrary order</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>a</span>.<span class='ident'>difference</span>(<span class='kw-2'>&</span><span class='ident'>b</span>) {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}
<span class='comment'>// Note that difference is not symmetric,</span>
<span class='comment'>// and `b - a` means something else.</span>
<span class='comment'>// This prints 0</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>b</span>.<span class='ident'>difference</span>(<span class='kw-2'>&</span><span class='ident'>a</span>) {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}</pre>
</div><h4 id='method.symmetric_difference' class='method'><code>fn <a href='#method.symmetric_difference' class='fnname'>symmetric_difference</a><'a>(&'a self, other: &'a Self) -> <a class='struct' href='../bit_set/struct.SymmetricDifference.html' title='bit_set::SymmetricDifference'>SymmetricDifference</a><'a, B></code></h4>
<div class='docblock'><p>Iterator over each usize stored in the symmetric difference of <code>self</code> and <code>other</code>.
See <a href="#method.symmetric_difference_with">symmetric_difference_with</a> for
an efficient in-place version.</p>
<h1 id='examples-13' class='section-header'><a href='#examples-13'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b01101000</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='number'>0b10100000</span>]);
<span class='comment'>// Print 0, 1, 4 in arbitrary order</span>
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='ident'>a</span>.<span class='ident'>symmetric_difference</span>(<span class='kw-2'>&</span><span class='ident'>b</span>) {
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
}</pre>
</div><h4 id='method.union_with' class='method'><code>fn <a href='#method.union_with' class='fnname'>union_with</a>(&mut self, other: &Self)</code></h4>
<div class='docblock'><p>Unions in-place with the specified other bit vector.</p>
<h1 id='examples-14' class='section-header'><a href='#examples-14'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='number'>0b01101000</span>;
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='number'>0b10100000</span>;
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='number'>0b11101000</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>a</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b</span>]);
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>res</span>]);
<span class='ident'>a</span>.<span class='ident'>union_with</span>(<span class='kw-2'>&</span><span class='ident'>b</span>);
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>a</span>, <span class='ident'>res</span>);</pre>
</div><h4 id='method.intersect_with' class='method'><code>fn <a href='#method.intersect_with' class='fnname'>intersect_with</a>(&mut self, other: &Self)</code></h4>
<div class='docblock'><p>Intersects in-place with the specified other bit vector.</p>
<h1 id='examples-15' class='section-header'><a href='#examples-15'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='number'>0b01101000</span>;
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='number'>0b10100000</span>;
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='number'>0b00100000</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>a</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b</span>]);
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>res</span>]);
<span class='ident'>a</span>.<span class='ident'>intersect_with</span>(<span class='kw-2'>&</span><span class='ident'>b</span>);
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>a</span>, <span class='ident'>res</span>);</pre>
</div><h4 id='method.difference_with' class='method'><code>fn <a href='#method.difference_with' class='fnname'>difference_with</a>(&mut self, other: &Self)</code></h4>
<div class='docblock'><p>Makes this bit vector the difference with the specified other bit vector
in-place.</p>
<h1 id='examples-16' class='section-header'><a href='#examples-16'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='number'>0b01101000</span>;
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='number'>0b10100000</span>;
<span class='kw'>let</span> <span class='ident'>a_b</span> <span class='op'>=</span> <span class='number'>0b01001000</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'>0b10000000</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'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>a</span>]);
<span class='kw'>let</span> <span class='ident'>bvb</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b</span>]);
<span class='kw'>let</span> <span class='ident'>bva_b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>a_b</span>]);
<span class='kw'>let</span> <span class='ident'>bvb_a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b_a</span>]);
<span class='ident'>bva</span>.<span class='ident'>difference_with</span>(<span class='kw-2'>&</span><span class='ident'>bvb</span>);
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>bva</span>, <span class='ident'>bva_b</span>);
<span class='kw'>let</span> <span class='ident'>bva</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</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'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b</span>]);
<span class='ident'>bvb</span>.<span class='ident'>difference_with</span>(<span class='kw-2'>&</span><span class='ident'>bva</span>);
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>bvb</span>, <span class='ident'>bvb_a</span>);</pre>
</div><h4 id='method.symmetric_difference_with' class='method'><code>fn <a href='#method.symmetric_difference_with' class='fnname'>symmetric_difference_with</a>(&mut self, other: &Self)</code></h4>
<div class='docblock'><p>Makes this bit vector the symmetric difference with the specified other
bit vector in-place.</p>
<h1 id='examples-17' class='section-header'><a href='#examples-17'>Examples</a></h1>
<pre class='rust rust-example-rendered'>
<span class='kw'>use</span> <span class='ident'>bit_set</span>::<span class='ident'>BitSet</span>;
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='number'>0b01101000</span>;
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='number'>0b10100000</span>;
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='number'>0b11001000</span>;
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>a</span>]);
<span class='kw'>let</span> <span class='ident'>b</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>b</span>]);
<span class='kw'>let</span> <span class='ident'>res</span> <span class='op'>=</span> <span class='ident'>BitSet</span>::<span class='ident'>from_bytes</span>(<span class='kw-2'>&</span>[<span class='ident'>res</span>]);
<span class='ident'>a</span>.<span class='ident'>symmetric_difference_with</span>(<span class='kw-2'>&</span><span class='ident'>b</span>);
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>a</span>, <span class='ident'>res</span>);</pre>
</div><h4 id='method.len' class='method'><code>fn <a href='#method.len' class='fnname'>len</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a></code></h4>
<div class='docblock'><p>Returns the number of set bits in this set.</p>
</div><h4 id='method.is_empty' class='method'><code>fn <a href='#method.is_empty' class='fnname'>is_empty</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Returns whether there are no bits set in this set</p>
</div><h4 id='method.clear' class='method'><code>fn <a href='#method.clear' class='fnname'>clear</a>(&mut self)</code></h4>
<div class='docblock'><p>Clears all bits in this set</p>
</div><h4 id='method.contains' class='method'><code>fn <a href='#method.contains' class='fnname'>contains</a>(&self, value: &<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Returns <code>true</code> if this set contains the specified integer.</p>
</div><h4 id='method.is_disjoint' class='method'><code>fn <a href='#method.is_disjoint' class='fnname'>is_disjoint</a>(&self, other: &Self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Returns <code>true</code> if the set has no elements in common with <code>other</code>.
This is equivalent to checking for an empty intersection.</p>
</div><h4 id='method.is_subset' class='method'><code>fn <a href='#method.is_subset' class='fnname'>is_subset</a>(&self, other: &Self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Returns <code>true</code> if the set is a subset of another.</p>
</div><h4 id='method.is_superset' class='method'><code>fn <a href='#method.is_superset' class='fnname'>is_superset</a>(&self, other: &Self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Returns <code>true</code> if the set is a superset of another.</p>
</div><h4 id='method.insert' class='method'><code>fn <a href='#method.insert' class='fnname'>insert</a>(&mut self, value: <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Adds a value to the set. Returns <code>true</code> if the value was not already
present in the set.</p>
</div><h4 id='method.remove' class='method'><code>fn <a href='#method.remove' class='fnname'>remove</a>(&mut self, value: &<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<div class='docblock'><p>Removes a value from the set. Returns <code>true</code> if the value was
present in the set.</p>
</div></div><h2 id='implementations'>Trait Implementations</h2><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html' title='core::clone::Clone'>Clone</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.clone' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> Self</code></h4>
<h4 id='method.clone_from' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: &Self)</code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/default/trait.Default.html' title='core::default::Default'>Default</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.default' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/default/trait.Default.html#tymethod.default' class='fnname'>default</a>() -> Self</code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/iter/trait.FromIterator.html' title='core::iter::FromIterator'>FromIterator</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.from_iter' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/iter/trait.FromIterator.html#tymethod.from_iter' class='fnname'>from_iter</a><I: <a class='trait' href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html' title='core::iter::IntoIterator'>IntoIterator</a><Item=<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>>>(iter: I) -> Self</code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/iter/trait.Extend.html' title='core::iter::Extend'>Extend</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.extend' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/iter/trait.Extend.html#tymethod.extend' class='fnname'>extend</a><I: <a class='trait' href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html' title='core::iter::IntoIterator'>IntoIterator</a><Item=<a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a>>>(&mut self, iter: I)</code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html' title='core::cmp::PartialOrd'>PartialOrd</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.partial_cmp' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&self, other: &Self) -> <a class='enum' href='https://doc.rust-lang.org/nightly/core/option/enum.Option.html' title='core::option::Option'>Option</a><<a class='enum' href='https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html' title='core::cmp::Ordering'>Ordering</a>></code></h4>
<h4 id='method.lt' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<h4 id='method.le' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<h4 id='method.gt' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<h4 id='method.ge' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html' title='core::cmp::Ord'>Ord</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.cmp' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&self, other: &Self) -> <a class='enum' href='https://doc.rust-lang.org/nightly/core/cmp/enum.Ordering.html' title='core::cmp::Ordering'>Ordering</a></code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html' title='core::cmp::PartialEq'>PartialEq</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.eq' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &Self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
<h4 id='method.ne' class='method'><span class="since">1.0.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.bool.html'>bool</a></code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/cmp/trait.Eq.html' title='core::cmp::Eq'>Eq</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'></div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html' title='core::fmt::Debug'>Debug</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.fmt' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, fmt: &mut <a class='struct' href='https://doc.rust-lang.org/nightly/core/fmt/struct.Formatter.html' title='core::fmt::Formatter'>Formatter</a>) -> <a class='type' href='https://doc.rust-lang.org/nightly/core/fmt/type.Result.html' title='core::fmt::Result'>Result</a></code></h4>
</div><h3 class='impl'><code>impl<B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html' title='core::hash::Hash'>Hash</a> for <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='method.hash' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><H: <a class='trait' href='https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html' title='core::hash::Hasher'>Hasher</a>>(&self, state: &mut H)</code></h4>
<h4 id='method.hash_slice' class='method'><span class="since">1.3.0</span><code>fn <a href='https://doc.rust-lang.org/nightly/core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a><H>(data: <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.slice.html'>&[Self]</a>, state: &mut H) <span class='where'>where H: <a class='trait' href='https://doc.rust-lang.org/nightly/core/hash/trait.Hasher.html' title='core::hash::Hasher'>Hasher</a></span></code></h4>
</div><h3 class='impl'><code>impl<'a, B: <a class='trait' href='../bit_vec/trait.BitBlock.html' title='bit_vec::BitBlock'>BitBlock</a>> <a class='trait' href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html' title='core::iter::IntoIterator'>IntoIterator</a> for &'a <a class='struct' href='../bit_set/struct.BitSet.html' title='bit_set::BitSet'>BitSet</a><B></code></h3><div class='impl-items'><h4 id='associatedtype.Item' class='type'><code>type <a href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html#associatedtype.Item' class='type'>Item</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/std/primitive.usize.html'>usize</a></code></h4>
<h4 id='associatedtype.IntoIter' class='type'><code>type <a href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html#associatedtype.IntoIter' class='type'>IntoIter</a> = <a class='struct' href='../bit_set/struct.Iter.html' title='bit_set::Iter'>Iter</a><'a, B></code></h4>
<h4 id='method.into_iter' class='method'><code>fn <a href='https://doc.rust-lang.org/nightly/core/iter/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -> <a class='struct' href='../bit_set/struct.Iter.html' title='bit_set::Iter'>Iter</a><'a, B></code></h4>
</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>?</dt>
<dd>Show this help dialog</dd>
<dt>S</dt>
<dd>Focus the search field</dd>
<dt>⇤</dt>
<dd>Move up in search results</dd>
<dt>⇥</dt>
<dd>Move down in search results</dd>
<dt>⏎</dt>
<dd>Go to active search result</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>
</div>
</div>
</aside>
<script>
window.rootPath = "../";
window.currentCrate = "bit_set";
window.playgroundUrl = "";
</script>
<script src="../jquery.js"></script>
<script src="../main.js"></script>
<script defer src="../search-index.js"></script>
</body>
</html>