1317 lines
No EOL
267 KiB
HTML
1317 lines
No EOL
267 KiB
HTML
<!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 `Vec` struct in crate `bitflags`.">
|
||
<meta name="keywords" content="rust, rustlang, rust-lang, Vec">
|
||
|
||
<title>bitflags::__core::vec::Vec - 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'>bitflags</a>::<wbr><a href='../index.html'>__core</a>::<wbr><a href='index.html'>vec</a></p><script>window.sidebarCurrent = {name: 'Vec', 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'>bitflags</a>::<wbr><a href='../index.html'>__core</a>::<wbr><a href='index.html'>vec</a>::<wbr><a class='struct' href=''>Vec</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-4008' class='srclink' href='https://doc.rust-lang.org/nightly/collections/vec/struct.Vec.html?gotosrc=4008' title='goto source code'>[src]</a></span></h1>
|
||
<pre class='rust struct'>pub struct Vec<T> {
|
||
// some fields omitted
|
||
}</pre><span class="since">1.0.0</span><div class='docblock'><p>A contiguous growable array type, written <code>Vec<T></code> but pronounced 'vector.'</p>
|
||
|
||
<h1 id='examples' class='section-header'><a href='#examples'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>new</span>();
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='number'>1</span>);
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='number'>2</span>);
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>len</span>(), <span class='number'>2</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>[<span class='number'>0</span>], <span class='number'>1</span>);
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>pop</span>(), <span class='prelude-val'>Some</span>(<span class='number'>2</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>len</span>(), <span class='number'>1</span>);
|
||
|
||
<span class='ident'>vec</span>[<span class='number'>0</span>] <span class='op'>=</span> <span class='number'>7</span>;
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>[<span class='number'>0</span>], <span class='number'>7</span>);
|
||
|
||
<span class='ident'>vec</span>.<span class='ident'>extend</span>([<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>].<span class='ident'>iter</span>().<span class='ident'>cloned</span>());
|
||
|
||
<span class='kw'>for</span> <span class='ident'>x</span> <span class='kw'>in</span> <span class='kw-2'>&</span><span class='ident'>vec</span> {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>x</span>);
|
||
}
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>7</span>, <span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>]);</pre>
|
||
|
||
<p>The <code>vec!</code> macro is provided to make initialization more convenient:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='number'>4</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>]);</pre>
|
||
|
||
<p>It can also initialize each element of a <code>Vec<T></code> with a given value:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>0</span>; <span class='number'>5</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>]);</pre>
|
||
|
||
<p>Use a <code>Vec<T></code> as an efficient stack:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>stack</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>new</span>();
|
||
|
||
<span class='ident'>stack</span>.<span class='ident'>push</span>(<span class='number'>1</span>);
|
||
<span class='ident'>stack</span>.<span class='ident'>push</span>(<span class='number'>2</span>);
|
||
<span class='ident'>stack</span>.<span class='ident'>push</span>(<span class='number'>3</span>);
|
||
|
||
<span class='kw'>while</span> <span class='kw'>let</span> <span class='prelude-val'>Some</span>(<span class='ident'>top</span>) <span class='op'>=</span> <span class='ident'>stack</span>.<span class='ident'>pop</span>() {
|
||
<span class='comment'>// Prints 3, 2, 1</span>
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>top</span>);
|
||
}</pre>
|
||
|
||
<h1 id='indexing' class='section-header'><a href='#indexing'>Indexing</a></h1>
|
||
<p>The Vec type allows to access values by index, because it implements the
|
||
<code>Index</code> trait. An example will be more explicit:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>(<span class='number'>0</span>, <span class='number'>2</span>, <span class='number'>4</span>, <span class='number'>6</span>);
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>v</span>[<span class='number'>1</span>]); <span class='comment'>// it will display '2'</span></pre>
|
||
|
||
<p>However be careful: if you try to access an index which isn't in the Vec,
|
||
your software will panic! You cannot do this:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>(<span class='number'>0</span>, <span class='number'>2</span>, <span class='number'>4</span>, <span class='number'>6</span>);
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>v</span>[<span class='number'>6</span>]); <span class='comment'>// it will panic!</span></pre>
|
||
|
||
<p>In conclusion: always check if the index you want to get really exists
|
||
before doing it.</p>
|
||
|
||
<h1 id='slicing' class='section-header'><a href='#slicing'>Slicing</a></h1>
|
||
<p>A Vec can be mutable. Slices, on the other hand, are read-only objects.
|
||
To get a slice, use "&". Example:</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>fn</span> <span class='ident'>read_slice</span>(<span class='ident'>slice</span>: <span class='kw-2'>&</span>[<span class='ident'>usize</span>]) {
|
||
<span class='comment'>// ...</span>
|
||
}
|
||
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>(<span class='number'>0</span>, <span class='number'>1</span>);
|
||
<span class='ident'>read_slice</span>(<span class='kw-2'>&</span><span class='ident'>v</span>);
|
||
|
||
<span class='comment'>// ... and that's all!</span>
|
||
<span class='comment'>// you can also do it like this:</span>
|
||
<span class='kw'>let</span> <span class='ident'>x</span> : <span class='kw-2'>&</span>[<span class='ident'>usize</span>] <span class='op'>=</span> <span class='kw-2'>&</span><span class='ident'>v</span>;</pre>
|
||
|
||
<p>In Rust, it's more common to pass slices as arguments rather than vectors
|
||
when you just want to provide a read access. The same goes for String and
|
||
&str.</p>
|
||
|
||
<h1 id='capacity-and-reallocation' class='section-header'><a href='#capacity-and-reallocation'>Capacity and reallocation</a></h1>
|
||
<p>The capacity of a vector is the amount of space allocated for any future
|
||
elements that will be added onto the vector. This is not to be confused with
|
||
the <em>length</em> of a vector, which specifies the number of actual elements
|
||
within the vector. If a vector's length exceeds its capacity, its capacity
|
||
will automatically be increased, but its elements will have to be
|
||
reallocated.</p>
|
||
|
||
<p>For example, a vector with capacity 10 and length 0 would be an empty vector
|
||
with space for 10 more elements. Pushing 10 or fewer elements onto the
|
||
vector will not change its capacity or cause reallocation to occur. However,
|
||
if the vector's length is increased to 11, it will have to reallocate, which
|
||
can be slow. For this reason, it is recommended to use <code>Vec::with_capacity</code>
|
||
whenever possible to specify how big the vector is expected to get.</p>
|
||
|
||
<h1 id='guarantees' class='section-header'><a href='#guarantees'>Guarantees</a></h1>
|
||
<p>Due to its incredibly fundamental nature, Vec makes a lot of guarantees
|
||
about its design. This ensures that it's as low-overhead as possible in
|
||
the general case, and can be correctly manipulated in primitive ways
|
||
by unsafe code. Note that these guarantees refer to an unqualified <code>Vec<T></code>.
|
||
If additional type parameters are added (e.g. to support custom allocators),
|
||
overriding their defaults may change the behavior.</p>
|
||
|
||
<p>Most fundamentally, Vec is and always will be a (pointer, capacity, length)
|
||
triplet. No more, no less. The order of these fields is completely
|
||
unspecified, and you should use the appropriate methods to modify these.
|
||
The pointer will never be null, so this type is null-pointer-optimized.</p>
|
||
|
||
<p>However, the pointer may not actually point to allocated memory. In particular,
|
||
if you construct a Vec with capacity 0 via <code>Vec::new()</code>, <code>vec![]</code>,
|
||
<code>Vec::with_capacity(0)</code>, or by calling <code>shrink_to_fit()</code> on an empty Vec, it
|
||
will not allocate memory. Similarly, if you store zero-sized types inside
|
||
a Vec, it will not allocate space for them. <em>Note that in this case the
|
||
Vec may not report a <code>capacity()</code> of 0</em>. Vec will allocate if and only
|
||
if <code>mem::size_of::<T>() * capacity() > 0</code>. In general, Vec's allocation
|
||
details are subtle enough that it is strongly recommended that you only
|
||
free memory allocated by a Vec by creating a new Vec and dropping it.</p>
|
||
|
||
<p>If a Vec <em>has</em> allocated memory, then the memory it points to is on the heap
|
||
(as defined by the allocator Rust is configured to use by default), and its
|
||
pointer points to <code>len()</code> initialized elements in order (what you would see
|
||
if you coerced it to a slice), followed by <code>capacity() - len()</code> logically
|
||
uninitialized elements.</p>
|
||
|
||
<p>Vec will never perform a "small optimization" where elements are actually
|
||
stored on the stack for two reasons:</p>
|
||
|
||
<ul>
|
||
<li><p>It would make it more difficult for unsafe code to correctly manipulate
|
||
a Vec. The contents of a Vec wouldn't have a stable address if it were
|
||
only moved, and it would be more difficult to determine if a Vec had
|
||
actually allocated memory.</p></li>
|
||
<li><p>It would penalize the general case, incurring an additional branch
|
||
on every access.</p></li>
|
||
</ul>
|
||
|
||
<p>Vec will never automatically shrink itself, even if completely empty. This
|
||
ensures no unnecessary allocations or deallocations occur. Emptying a Vec
|
||
and then filling it back up to the same <code>len()</code> should incur no calls to
|
||
the allocator. If you wish to free up unused memory, use <code>shrink_to_fit</code>.</p>
|
||
|
||
<p><code>push</code> and <code>insert</code> will never (re)allocate if the reported capacity is
|
||
sufficient. <code>push</code> and <code>insert</code> <em>will</em> (re)allocate if <code>len() == capacity()</code>.
|
||
That is, the reported capacity is completely accurate, and can be relied on.
|
||
It can even be used to manually free the memory allocated by a Vec if
|
||
desired. Bulk insertion methods <em>may</em> reallocate, even when not necessary.</p>
|
||
|
||
<p>Vec does not guarantee any particular growth strategy when reallocating
|
||
when full, nor when <code>reserve</code> is called. The current strategy is basic
|
||
and it may prove desirable to use a non-constant growth factor. Whatever
|
||
strategy is used will of course guarantee <code>O(1)</code> amortized <code>push</code>.</p>
|
||
|
||
<p><code>vec![x; n]</code>, <code>vec![a, b, c, d]</code>, and <code>Vec::with_capacity(n)</code>, will all
|
||
produce a Vec with exactly the requested capacity. If <code>len() == capacity()</code>,
|
||
(as is the case for the <code>vec!</code> macro), then a <code>Vec<T></code> can be converted
|
||
to and from a <code>Box<[T]></code> without reallocating or moving the elements.</p>
|
||
|
||
<p>Vec will not specifically overwrite any data that is removed from it,
|
||
but also won't specifically preserve it. Its uninitialized memory is
|
||
scratch space that it may use however it wants. It will generally just do
|
||
whatever is most efficient or otherwise easy to implement. Do not rely on
|
||
removed data to be erased for security purposes. Even if you drop a Vec, its
|
||
buffer may simply be reused by another Vec. Even if you zero a Vec's memory
|
||
first, that may not actually happen because the optimizer does not consider
|
||
this a side-effect that must be preserved.</p>
|
||
|
||
<p>Vec does not currently guarantee the order in which elements are dropped
|
||
(the order has changed in the past, and may change again).</p>
|
||
</div><h2 id='methods'>Methods</h2><h3 class='impl'><code>impl<T> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.new' class='method'><code>fn <a href='#method.new' class='fnname'>new</a>() -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<div class='docblock'><p>Constructs a new, empty <code>Vec<T></code>.</p>
|
||
|
||
<p>The vector will not allocate until elements are pushed onto it.</p>
|
||
|
||
<h1 id='examples-1' class='section-header'><a href='#examples-1'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span>: <span class='ident'>Vec</span><span class='op'><</span><span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>Vec</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>(capacity: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<div class='docblock'><p>Constructs a new, empty <code>Vec<T></code> with the specified capacity.</p>
|
||
|
||
<p>The vector will be able to hold exactly <code>capacity</code> elements without
|
||
reallocating. If <code>capacity</code> is 0, the vector will not allocate.</p>
|
||
|
||
<p>It is important to note that this function does not specify the <em>length</em>
|
||
of the returned vector, but only the <em>capacity</em>. (For an explanation of
|
||
the difference between length and capacity, see the main <code>Vec<T></code> docs
|
||
above, 'Capacity and reallocation'.)</p>
|
||
|
||
<h1 id='examples-2' class='section-header'><a href='#examples-2'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>with_capacity</span>(<span class='number'>10</span>);
|
||
|
||
<span class='comment'>// The vector contains no items, even though it has capacity for more</span>
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>len</span>(), <span class='number'>0</span>);
|
||
|
||
<span class='comment'>// These are all done without reallocating...</span>
|
||
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='number'>10</span> {
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='ident'>i</span>);
|
||
}
|
||
|
||
<span class='comment'>// ...but this may make the vector reallocate</span>
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='number'>11</span>);</pre>
|
||
</div><h4 id='method.from_raw_parts' class='method'><code>unsafe fn <a href='#method.from_raw_parts' class='fnname'>from_raw_parts</a>(ptr: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.pointer.html'>*mut T</a>, length: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, capacity: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<div class='docblock'><p>Creates a <code>Vec<T></code> directly from the raw components of another vector.</p>
|
||
|
||
<h1 id='safety' class='section-header'><a href='#safety'>Safety</a></h1>
|
||
<p>This is highly unsafe, due to the number of invariants that aren't
|
||
checked:</p>
|
||
|
||
<ul>
|
||
<li><code>ptr</code> needs to have been previously allocated via <code>String</code>/<code>Vec<T></code>
|
||
(at least, it's highly likely to be incorrect if it wasn't).</li>
|
||
<li><code>length</code> needs to be the length that less than or equal to <code>capacity</code>.</li>
|
||
<li><code>capacity</code> needs to be the capacity that the pointer was allocated with.</li>
|
||
</ul>
|
||
|
||
<p>Violating these may cause problems like corrupting the allocator's
|
||
internal datastructures.</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'>std</span>::<span class='ident'>ptr</span>;
|
||
<span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>mem</span>;
|
||
|
||
<span class='kw'>fn</span> <span class='ident'>main</span>() {
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
|
||
<span class='comment'>// Pull out the various important pieces of information about `v`</span>
|
||
<span class='kw'>let</span> <span class='ident'>p</span> <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>as_mut_ptr</span>();
|
||
<span class='kw'>let</span> <span class='ident'>len</span> <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>len</span>();
|
||
<span class='kw'>let</span> <span class='ident'>cap</span> <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>capacity</span>();
|
||
|
||
<span class='kw'>unsafe</span> {
|
||
<span class='comment'>// Cast `v` into the void: no destructor run, so we are in</span>
|
||
<span class='comment'>// complete control of the allocation to which `p` points.</span>
|
||
<span class='ident'>mem</span>::<span class='ident'>forget</span>(<span class='ident'>v</span>);
|
||
|
||
<span class='comment'>// Overwrite memory with 4, 5, 6</span>
|
||
<span class='kw'>for</span> <span class='ident'>i</span> <span class='kw'>in</span> <span class='number'>0</span>..<span class='ident'>len</span> <span class='kw'>as</span> <span class='ident'>isize</span> {
|
||
<span class='ident'>ptr</span>::<span class='ident'>write</span>(<span class='ident'>p</span>.<span class='ident'>offset</span>(<span class='ident'>i</span>), <span class='number'>4</span> <span class='op'>+</span> <span class='ident'>i</span>);
|
||
}
|
||
|
||
<span class='comment'>// Put everything back together into a Vec</span>
|
||
<span class='kw'>let</span> <span class='ident'>rebuilt</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>from_raw_parts</span>(<span class='ident'>p</span>, <span class='ident'>len</span>, <span class='ident'>cap</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>rebuilt</span>, [<span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>]);
|
||
}
|
||
}</pre>
|
||
</div><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/bitflags/primitive.usize.html'>usize</a></code></h4>
|
||
<div class='docblock'><p>Returns the number of elements the vector can hold without
|
||
reallocating.</p>
|
||
|
||
<h1 id='examples-4' class='section-header'><a href='#examples-4'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>vec</span>: <span class='ident'>Vec</span><span class='op'><</span><span class='ident'>i32</span><span class='op'>></span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>with_capacity</span>(<span class='number'>10</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>capacity</span>(), <span class='number'>10</span>);</pre>
|
||
</div><h4 id='method.reserve' class='method'><code>fn <a href='#method.reserve' class='fnname'>reserve</a>(&mut self, additional: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>)</code></h4>
|
||
<div class='docblock'><p>Reserves capacity for at least <code>additional</code> more elements to be inserted
|
||
in the given <code>Vec<T></code>. The collection may reserve more space to avoid
|
||
frequent reallocations.</p>
|
||
|
||
<h1 id='panics' class='section-header'><a href='#panics'>Panics</a></h1>
|
||
<p>Panics if the new capacity overflows <code>usize</code>.</p>
|
||
|
||
<h1 id='examples-5' class='section-header'><a href='#examples-5'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>reserve</span>(<span class='number'>10</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>11</span>);</pre>
|
||
</div><h4 id='method.reserve_exact' class='method'><code>fn <a href='#method.reserve_exact' class='fnname'>reserve_exact</a>(&mut self, additional: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>)</code></h4>
|
||
<div class='docblock'><p>Reserves the minimum capacity for exactly <code>additional</code> more elements to
|
||
be inserted in the given <code>Vec<T></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-1' class='section-header'><a href='#panics-1'>Panics</a></h1>
|
||
<p>Panics if the new capacity overflows <code>usize</code>.</p>
|
||
|
||
<h1 id='examples-6' class='section-header'><a href='#examples-6'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>reserve_exact</span>(<span class='number'>10</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>11</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>Shrinks the capacity of the vector as much as possible.</p>
|
||
|
||
<p>It will drop down as close as possible to the length but the allocator
|
||
may still inform the vector that there is space for a few more elements.</p>
|
||
|
||
<h1 id='examples-7' class='section-header'><a href='#examples-7'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>with_capacity</span>(<span class='number'>10</span>);
|
||
<span class='ident'>vec</span>.<span class='ident'>extend</span>([<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>].<span class='ident'>iter</span>().<span class='ident'>cloned</span>());
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>capacity</span>(), <span class='number'>10</span>);
|
||
<span class='ident'>vec</span>.<span class='ident'>shrink_to_fit</span>();
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>capacity</span>() <span class='op'>>=</span> <span class='number'>3</span>);</pre>
|
||
</div><h4 id='method.into_boxed_slice' class='method'><code>fn <a href='#method.into_boxed_slice' class='fnname'>into_boxed_slice</a>(self) -> <a class='struct' href='../../../bitflags/__core/boxed/struct.Box.html' title='bitflags::__core::boxed::Box'>Box</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>></code></h4>
|
||
<div class='docblock'><p>Converts the vector into Box<[T]>.</p>
|
||
|
||
<p>Note that this will drop any excess capacity. Calling this and
|
||
converting back to a vector with <code>into_vec()</code> is equivalent to calling
|
||
<code>shrink_to_fit()</code>.</p>
|
||
</div><h4 id='method.truncate' class='method'><code>fn <a href='#method.truncate' class='fnname'>truncate</a>(&mut self, len: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>)</code></h4>
|
||
<div class='docblock'><p>Shorten a vector to be <code>len</code> elements long, 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-8' class='section-header'><a href='#examples-8'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>truncate</span>(<span class='number'>2</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>]);</pre>
|
||
</div><h4 id='method.as_slice' class='method'><span class="since">1.7.0</span><code>fn <a href='#method.as_slice' class='fnname'>as_slice</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
<div class='docblock'><p>Extracts a slice containing the entire vector.</p>
|
||
|
||
<p>Equivalent to <code>&s[..]</code>.</p>
|
||
</div><h4 id='method.as_mut_slice' class='method'><span class="since">1.7.0</span><code>fn <a href='#method.as_mut_slice' class='fnname'>as_mut_slice</a>(&mut self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
<div class='docblock'><p>Extracts a mutable slice of the entire vector.</p>
|
||
|
||
<p>Equivalent to <code>&mut s[..]</code>.</p>
|
||
</div><h4 id='method.set_len' class='method'><code>unsafe fn <a href='#method.set_len' class='fnname'>set_len</a>(&mut self, len: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>)</code></h4>
|
||
<div class='docblock'><p>Sets the length of a vector.</p>
|
||
|
||
<p>This will explicitly set the size of the vector, without actually
|
||
modifying its buffers, so it is up to the caller to ensure that the
|
||
vector is actually the specified size.</p>
|
||
|
||
<h1 id='examples-9' class='section-header'><a href='#examples-9'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>];
|
||
<span class='kw'>unsafe</span> {
|
||
<span class='ident'>v</span>.<span class='ident'>set_len</span>(<span class='number'>1</span>);
|
||
}</pre>
|
||
</div><h4 id='method.swap_remove' class='method'><code>fn <a href='#method.swap_remove' class='fnname'>swap_remove</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> T</code></h4>
|
||
<div class='docblock'><p>Removes an element from anywhere in the vector and return it, replacing
|
||
it with the last element.</p>
|
||
|
||
<p>This does not preserve ordering, but is O(1).</p>
|
||
|
||
<h1 id='panics-2' class='section-header'><a href='#panics-2'>Panics</a></h1>
|
||
<p>Panics if <code>index</code> is out of bounds.</p>
|
||
|
||
<h1 id='examples-10' class='section-header'><a href='#examples-10'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='string'>"foo"</span>, <span class='string'>"bar"</span>, <span class='string'>"baz"</span>, <span class='string'>"qux"</span>];
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>swap_remove</span>(<span class='number'>1</span>), <span class='string'>"bar"</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>, [<span class='string'>"foo"</span>, <span class='string'>"qux"</span>, <span class='string'>"baz"</span>]);
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>swap_remove</span>(<span class='number'>0</span>), <span class='string'>"foo"</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>, [<span class='string'>"baz"</span>, <span class='string'>"qux"</span>]);</pre>
|
||
</div><h4 id='method.insert' class='method'><code>fn <a href='#method.insert' class='fnname'>insert</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, element: T)</code></h4>
|
||
<div class='docblock'><p>Inserts an element at position <code>index</code> within the vector, shifting all
|
||
elements after it to the right.</p>
|
||
|
||
<h1 id='panics-3' class='section-header'><a href='#panics-3'>Panics</a></h1>
|
||
<p>Panics if <code>index</code> is greater than the vector's length.</p>
|
||
|
||
<h1 id='examples-11' class='section-header'><a href='#examples-11'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>insert</span>(<span class='number'>1</span>, <span class='number'>4</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>4</span>, <span class='number'>2</span>, <span class='number'>3</span>]);
|
||
<span class='ident'>vec</span>.<span class='ident'>insert</span>(<span class='number'>4</span>, <span class='number'>5</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>4</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>5</span>]);</pre>
|
||
</div><h4 id='method.remove' class='method'><code>fn <a href='#method.remove' class='fnname'>remove</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> T</code></h4>
|
||
<div class='docblock'><p>Removes and returns the element at position <code>index</code> within the vector,
|
||
shifting all elements after it to the left.</p>
|
||
|
||
<h1 id='panics-4' class='section-header'><a href='#panics-4'>Panics</a></h1>
|
||
<p>Panics if <code>index</code> is out of bounds.</p>
|
||
|
||
<h1 id='examples-12' class='section-header'><a href='#examples-12'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>remove</span>(<span class='number'>1</span>), <span class='number'>2</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>, [<span class='number'>1</span>, <span class='number'>3</span>]);</pre>
|
||
</div><h4 id='method.retain' class='method'><code>fn <a href='#method.retain' class='fnname'>retain</a><F>(&mut self, f: F) <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Retains only the elements specified by the predicate.</p>
|
||
|
||
<p>In other words, remove all elements <code>e</code> such that <code>f(&e)</code> returns false.
|
||
This method operates in place and preserves the order of the retained
|
||
elements.</p>
|
||
|
||
<h1 id='examples-13' class='section-header'><a href='#examples-13'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>retain</span>(<span class='op'>|</span><span class='kw-2'>&</span><span class='ident'>x</span><span class='op'>|</span> <span class='ident'>x</span><span class='op'>%</span><span class='number'>2</span> <span class='op'>==</span> <span class='number'>0</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>2</span>, <span class='number'>4</span>]);</pre>
|
||
</div><h4 id='method.push' class='method'><code>fn <a href='#method.push' class='fnname'>push</a>(&mut self, value: T)</code></h4>
|
||
<div class='docblock'><p>Appends an element to the back of a collection.</p>
|
||
|
||
<h1 id='panics-5' class='section-header'><a href='#panics-5'>Panics</a></h1>
|
||
<p>Panics if the number of elements in the vector overflows a <code>usize</code>.</p>
|
||
|
||
<h1 id='examples-14' class='section-header'><a href='#examples-14'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>push</span>(<span class='number'>3</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>]);</pre>
|
||
</div><h4 id='method.pop' class='method'><code>fn <a href='#method.pop' class='fnname'>pop</a>(&mut self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><T></code></h4>
|
||
<div class='docblock'><p>Removes the last element from a vector and returns it, or <code>None</code> if it
|
||
is empty.</p>
|
||
|
||
<h1 id='examples-15' class='section-header'><a href='#examples-15'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>.<span class='ident'>pop</span>(), <span class='prelude-val'>Some</span>(<span class='number'>3</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>]);</pre>
|
||
</div><h4 id='method.append' class='method'><span class="since">1.4.0</span><code>fn <a href='#method.append' class='fnname'>append</a>(&mut self, other: &mut <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>)</code></h4>
|
||
<div class='docblock'><p>Moves all the elements of <code>other</code> into <code>Self</code>, leaving <code>other</code> empty.</p>
|
||
|
||
<h1 id='panics-6' class='section-header'><a href='#panics-6'>Panics</a></h1>
|
||
<p>Panics if the number of elements in the vector overflows a <code>usize</code>.</p>
|
||
|
||
<h1 id='examples-16' class='section-header'><a href='#examples-16'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec2</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>append</span>(<span class='kw-2'>&</span><span class='kw-2'>mut</span> <span class='ident'>vec2</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>]);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec2</span>, []);</pre>
|
||
</div><h4 id='method.drain' class='method'><span class="since">1.6.0</span><code>fn <a href='#method.drain' class='fnname'>drain</a><R>(&mut self, range: R) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Drain.html' title='bitflags::__core::vec::Drain'>Drain</a><T> <span class='where'>where R: <a class='trait' href='https://doc.rust-lang.org/nightly/collections/range/trait.RangeArgument.html' title='collections::range::RangeArgument'>RangeArgument</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>></span></code></h4>
|
||
<div class='docblock'><p>Create a draining iterator that removes the specified range in the vector
|
||
and yields the removed items.</p>
|
||
|
||
<p>Note 1: The element range is removed even if the iterator is not
|
||
consumed until the end.</p>
|
||
|
||
<p>Note 2: It is unspecified how many elements are removed from the vector,
|
||
if the <code>Drain</code> value is leaked.</p>
|
||
|
||
<h1 id='panics-7' class='section-header'><a href='#panics-7'>Panics</a></h1>
|
||
<p>Panics if the starting point is greater than the end point or if
|
||
the end point is greater than the length of the vector.</p>
|
||
|
||
<h1 id='examples-17' class='section-header'><a href='#examples-17'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='kw'>let</span> <span class='ident'>u</span>: <span class='ident'>Vec</span><span class='op'><</span>_<span class='op'>></span> <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>drain</span>(<span class='number'>1</span>..).<span class='ident'>collect</span>();
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>, <span class='kw-2'>&</span>[<span class='number'>1</span>]);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>u</span>, <span class='kw-2'>&</span>[<span class='number'>2</span>, <span class='number'>3</span>]);
|
||
|
||
<span class='comment'>// A full range clears the vector</span>
|
||
<span class='ident'>v</span>.<span class='ident'>drain</span>(..);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>v</span>, <span class='kw-2'>&</span>[]);</pre>
|
||
</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 the vector, removing all values.</p>
|
||
|
||
<h1 id='examples-18' class='section-header'><a href='#examples-18'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
|
||
<span class='ident'>v</span>.<span class='ident'>clear</span>();
|
||
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>is_empty</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/bitflags/primitive.usize.html'>usize</a></code></h4>
|
||
<div class='docblock'><p>Returns the number of elements in the vector.</p>
|
||
|
||
<h1 id='examples-19' class='section-header'><a href='#examples-19'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>a</span>.<span class='ident'>len</span>(), <span class='number'>3</span>);</pre>
|
||
</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/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<div class='docblock'><p>Returns <code>true</code> if the vector contains no elements.</p>
|
||
|
||
<h1 id='examples-20' class='section-header'><a href='#examples-20'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='ident'>Vec</span>::<span class='ident'>new</span>();
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>is_empty</span>());
|
||
|
||
<span class='ident'>v</span>.<span class='ident'>push</span>(<span class='number'>1</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>is_empty</span>());</pre>
|
||
</div><h4 id='method.split_off' class='method'><span class="since">1.4.0</span><code>fn <a href='#method.split_off' class='fnname'>split_off</a>(&mut self, at: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<div class='docblock'><p>Splits the collection into two at the given index.</p>
|
||
|
||
<p>Returns a newly allocated <code>Self</code>. <code>self</code> contains elements <code>[0, at)</code>,
|
||
and the returned <code>Self</code> contains elements <code>[at, len)</code>.</p>
|
||
|
||
<p>Note that the capacity of <code>self</code> does not change.</p>
|
||
|
||
<h1 id='panics-8' class='section-header'><a href='#panics-8'>Panics</a></h1>
|
||
<p>Panics if <code>at > len</code>.</p>
|
||
|
||
<h1 id='examples-21' class='section-header'><a href='#examples-21'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>,<span class='number'>2</span>,<span class='number'>3</span>];
|
||
<span class='kw'>let</span> <span class='ident'>vec2</span> <span class='op'>=</span> <span class='ident'>vec</span>.<span class='ident'>split_off</span>(<span class='number'>1</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>]);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec2</span>, [<span class='number'>2</span>, <span class='number'>3</span>]);</pre>
|
||
</div></div><h3 class='impl'><code>impl<T> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a></span></code></h3><div class='impl-items'><h4 id='method.resize' class='method'><span class="since">1.5.0</span><code>fn <a href='#method.resize' class='fnname'>resize</a>(&mut self, new_len: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, value: T)</code></h4>
|
||
<div class='docblock'><p>Resizes the <code>Vec</code> in-place so that <code>len()</code> is equal to <code>new_len</code>.</p>
|
||
|
||
<p>If <code>new_len</code> is greater than <code>len()</code>, the <code>Vec</code> is extended by the
|
||
difference, with each additional slot filled with <code>value</code>.
|
||
If <code>new_len</code> is less than <code>len()</code>, the <code>Vec</code> is simply truncated.</p>
|
||
|
||
<h1 id='examples-22' class='section-header'><a href='#examples-22'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='string'>"hello"</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>resize</span>(<span class='number'>3</span>, <span class='string'>"world"</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='string'>"hello"</span>, <span class='string'>"world"</span>, <span class='string'>"world"</span>]);
|
||
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>resize</span>(<span class='number'>2</span>, <span class='number'>0</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>]);</pre>
|
||
</div><h4 id='method.extend_from_slice' class='method'><span class="since">1.6.0</span><code>fn <a href='#method.extend_from_slice' class='fnname'>extend_from_slice</a>(&mut self, other: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>)</code></h4>
|
||
<div class='docblock'><p>Appends all elements in a slice to the <code>Vec</code>.</p>
|
||
|
||
<p>Iterates over the slice <code>other</code>, clones each element, and then appends
|
||
it to this <code>Vec</code>. The <code>other</code> vector is traversed in-order.</p>
|
||
|
||
<p>Note that this function is same as <code>extend</code> except that it is
|
||
specialized to work with slices instead. If and when Rust gets
|
||
specialization this function will likely be deprecated (but still
|
||
available).</p>
|
||
|
||
<h1 id='examples-23' class='section-header'><a href='#examples-23'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>];
|
||
<span class='ident'>vec</span>.<span class='ident'>extend_from_slice</span>(<span class='kw-2'>&</span>[<span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>]);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>]);</pre>
|
||
</div></div><h3 class='impl'><code>impl<T> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><T></span></code></h3><div class='impl-items'><h4 id='method.dedup' class='method'><code>fn <a href='#method.dedup' class='fnname'>dedup</a>(&mut self)</code></h4>
|
||
<div class='docblock'><p>Removes consecutive repeated elements in the vector.</p>
|
||
|
||
<p>If the vector is sorted, this removes all duplicates.</p>
|
||
|
||
<h1 id='examples-24' class='section-header'><a href='#examples-24'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>vec</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>2</span>];
|
||
|
||
<span class='ident'>vec</span>.<span class='ident'>dedup</span>();
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>vec</span>, [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>2</span>]);</pre>
|
||
</div></div><h2 id='deref-methods'>Methods from <a class='trait' href='../../../bitflags/__core/ops/trait.Deref.html' title='bitflags::__core::ops::Deref'>Deref</a><Target=<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>></h2><div class='impl-items'><h4 id='method.len-1' class='method'><code>fn <a href='#method.len' class='fnname'>len</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a></code></h4>
|
||
<div class='docblock'><p>Returns the number of elements in the slice.</p>
|
||
|
||
<h1 id='example' class='section-header'><a href='#example'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>a</span>.<span class='ident'>len</span>(), <span class='number'>3</span>);</pre>
|
||
</div><h4 id='method.is_empty-1' 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/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<div class='docblock'><p>Returns true if the slice has a length of 0</p>
|
||
|
||
<h1 id='example-1' class='section-header'><a href='#example-1'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>a</span>.<span class='ident'>is_empty</span>());</pre>
|
||
</div><h4 id='method.first' class='method'><code>fn <a href='#method.first' class='fnname'>first</a>(&self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&T></code></h4>
|
||
<div class='docblock'><p>Returns the first element of a slice, or <code>None</code> if it is empty.</p>
|
||
|
||
<h1 id='examples-25' class='section-header'><a href='#examples-25'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>Some</span>(<span class='kw-2'>&</span><span class='number'>10</span>), <span class='ident'>v</span>.<span class='ident'>first</span>());
|
||
|
||
<span class='kw'>let</span> <span class='ident'>w</span>: <span class='kw-2'>&</span>[<span class='ident'>i32</span>] <span class='op'>=</span> <span class='kw-2'>&</span>[];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>None</span>, <span class='ident'>w</span>.<span class='ident'>first</span>());</pre>
|
||
</div><h4 id='method.first_mut' class='method'><code>fn <a href='#method.first_mut' class='fnname'>first_mut</a>(&mut self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&mut T></code></h4>
|
||
<div class='docblock'><p>Returns a mutable pointer to the first element of a slice, or <code>None</code> if it is empty</p>
|
||
</div><h4 id='method.split_first' class='method'><span class="since">1.5.0</span><code>fn <a href='#method.split_first' class='fnname'>split_first</a>(&self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a>&T, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a>></code></h4>
|
||
<div class='docblock'><p>Returns the first and all the rest of the elements of a slice.</p>
|
||
</div><h4 id='method.split_first_mut' class='method'><span class="since">1.5.0</span><code>fn <a href='#method.split_first_mut' class='fnname'>split_first_mut</a>(&mut self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a>&mut T, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a>></code></h4>
|
||
<div class='docblock'><p>Returns the first and all the rest of the elements of a slice.</p>
|
||
</div><h4 id='method.split_last' class='method'><span class="since">1.5.0</span><code>fn <a href='#method.split_last' class='fnname'>split_last</a>(&self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a>&T, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a>></code></h4>
|
||
<div class='docblock'><p>Returns the last and all the rest of the elements of a slice.</p>
|
||
</div><h4 id='method.split_last_mut' class='method'><span class="since">1.5.0</span><code>fn <a href='#method.split_last_mut' class='fnname'>split_last_mut</a>(&mut self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a>&mut T, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a>></code></h4>
|
||
<div class='docblock'><p>Returns the last and all the rest of the elements of a slice.</p>
|
||
</div><h4 id='method.last' class='method'><code>fn <a href='#method.last' class='fnname'>last</a>(&self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&T></code></h4>
|
||
<div class='docblock'><p>Returns the last element of a slice, or <code>None</code> if it is empty.</p>
|
||
|
||
<h1 id='examples-26' class='section-header'><a href='#examples-26'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>Some</span>(<span class='kw-2'>&</span><span class='number'>30</span>), <span class='ident'>v</span>.<span class='ident'>last</span>());
|
||
|
||
<span class='kw'>let</span> <span class='ident'>w</span>: <span class='kw-2'>&</span>[<span class='ident'>i32</span>] <span class='op'>=</span> <span class='kw-2'>&</span>[];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>None</span>, <span class='ident'>w</span>.<span class='ident'>last</span>());</pre>
|
||
</div><h4 id='method.last_mut' class='method'><code>fn <a href='#method.last_mut' class='fnname'>last_mut</a>(&mut self) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&mut T></code></h4>
|
||
<div class='docblock'><p>Returns a mutable pointer to the last item in the slice.</p>
|
||
</div><h4 id='method.get' class='method'><code>fn <a href='#method.get' class='fnname'>get</a>(&self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&T></code></h4>
|
||
<div class='docblock'><p>Returns the element of a slice at the given index, or <code>None</code> if the
|
||
index is out of bounds.</p>
|
||
|
||
<h1 id='examples-27' class='section-header'><a href='#examples-27'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>Some</span>(<span class='kw-2'>&</span><span class='number'>40</span>), <span class='ident'>v</span>.<span class='ident'>get</span>(<span class='number'>1</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='prelude-val'>None</span>, <span class='ident'>v</span>.<span class='ident'>get</span>(<span class='number'>3</span>));</pre>
|
||
</div><h4 id='method.get_mut' class='method'><code>fn <a href='#method.get_mut' class='fnname'>get_mut</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><&mut T></code></h4>
|
||
<div class='docblock'><p>Returns a mutable reference to the element at the given index,
|
||
or <code>None</code> if the index is out of bounds</p>
|
||
</div><h4 id='method.get_unchecked' class='method'><code>unsafe fn <a href='#method.get_unchecked' class='fnname'>get_unchecked</a>(&self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> &T</code></h4>
|
||
<div class='docblock'><p>Returns a pointer to the element at the given index, without doing
|
||
bounds checking.</p>
|
||
</div><h4 id='method.get_unchecked_mut' class='method'><code>unsafe fn <a href='#method.get_unchecked_mut' class='fnname'>get_unchecked_mut</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> &mut T</code></h4>
|
||
<div class='docblock'><p>Returns an unsafe mutable pointer to the element in index</p>
|
||
</div><h4 id='method.as_ptr' class='method'><code>fn <a href='#method.as_ptr' class='fnname'>as_ptr</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.pointer.html'>*const T</a></code></h4>
|
||
<div class='docblock'><p>Returns an raw pointer to the slice's buffer</p>
|
||
|
||
<p>The caller must ensure that the slice outlives the pointer this
|
||
function returns, or else it will end up pointing to garbage.</p>
|
||
|
||
<p>Modifying the slice may cause its buffer to be reallocated, which
|
||
would also make any pointers to it invalid.</p>
|
||
</div><h4 id='method.as_mut_ptr' class='method'><code>fn <a href='#method.as_mut_ptr' class='fnname'>as_mut_ptr</a>(&mut self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.pointer.html'>*mut T</a></code></h4>
|
||
<div class='docblock'><p>Returns an unsafe mutable pointer to the slice's buffer.</p>
|
||
|
||
<p>The caller must ensure that the slice outlives the pointer this
|
||
function returns, or else it will end up pointing to garbage.</p>
|
||
|
||
<p>Modifying the slice may cause its buffer to be reallocated, which
|
||
would also make any pointers to it invalid.</p>
|
||
</div><h4 id='method.swap' class='method'><code>fn <a href='#method.swap' class='fnname'>swap</a>(&mut self, a: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, b: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>)</code></h4>
|
||
<div class='docblock'><p>Swaps two elements in a slice.</p>
|
||
|
||
<h1 id='arguments' class='section-header'><a href='#arguments'>Arguments</a></h1>
|
||
<ul>
|
||
<li>a - The index of the first element</li>
|
||
<li>b - The index of the second element</li>
|
||
</ul>
|
||
|
||
<h1 id='panics-9' class='section-header'><a href='#panics-9'>Panics</a></h1>
|
||
<p>Panics if <code>a</code> or <code>b</code> are out of bounds.</p>
|
||
|
||
<h1 id='example-2' class='section-header'><a href='#example-2'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='string'>"a"</span>, <span class='string'>"b"</span>, <span class='string'>"c"</span>, <span class='string'>"d"</span>];
|
||
<span class='ident'>v</span>.<span class='ident'>swap</span>(<span class='number'>1</span>, <span class='number'>3</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='string'>"a"</span>, <span class='string'>"d"</span>, <span class='string'>"c"</span>, <span class='string'>"b"</span>]);</pre>
|
||
</div><h4 id='method.reverse' class='method'><code>fn <a href='#method.reverse' class='fnname'>reverse</a>(&mut self)</code></h4>
|
||
<div class='docblock'><p>Reverse the order of elements in a slice, in place.</p>
|
||
|
||
<h1 id='example-3' class='section-header'><a href='#example-3'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
<span class='ident'>v</span>.<span class='ident'>reverse</span>();
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='number'>3</span>, <span class='number'>2</span>, <span class='number'>1</span>]);</pre>
|
||
</div><h4 id='method.iter' class='method'><code>fn <a href='#method.iter' class='fnname'>iter</a>(&self) -> <a class='struct' href='../../../bitflags/__core/slice/struct.Iter.html' title='bitflags::__core::slice::Iter'>Iter</a><T></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over the slice.</p>
|
||
</div><h4 id='method.iter_mut' class='method'><code>fn <a href='#method.iter_mut' class='fnname'>iter_mut</a>(&mut self) -> <a class='struct' href='../../../bitflags/__core/slice/struct.IterMut.html' title='bitflags::__core::slice::IterMut'>IterMut</a><T></code></h4>
|
||
<div class='docblock'><p>Returns an iterator that allows modifying each value</p>
|
||
</div><h4 id='method.windows' class='method'><code>fn <a href='#method.windows' class='fnname'>windows</a>(&self, size: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/slice/struct.Windows.html' title='bitflags::__core::slice::Windows'>Windows</a><T></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over all contiguous windows of length
|
||
<code>size</code>. The windows overlap. If the slice is shorter than
|
||
<code>size</code>, the iterator returns no values.</p>
|
||
|
||
<h1 id='panics-10' class='section-header'><a href='#panics-10'>Panics</a></h1>
|
||
<p>Panics if <code>size</code> is 0.</p>
|
||
|
||
<h1 id='example-4' class='section-header'><a href='#example-4'>Example</a></h1>
|
||
<p>Print the adjacent pairs of a slice (i.e. <code>[1,2]</code>, <code>[2,3]</code>,
|
||
<code>[3,4]</code>):</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='kw-2'>&</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>];
|
||
<span class='kw'>for</span> <span class='ident'>win</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>windows</span>(<span class='number'>2</span>) {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{:?}"</span>, <span class='ident'>win</span>);
|
||
}</pre>
|
||
</div><h4 id='method.chunks' class='method'><code>fn <a href='#method.chunks' class='fnname'>chunks</a>(&self, size: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/slice/struct.Chunks.html' title='bitflags::__core::slice::Chunks'>Chunks</a><T></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over <code>size</code> elements of the slice at a
|
||
time. The chunks are slices and do not overlap. If <code>size</code> does not divide the
|
||
length of the slice, then the last chunk will not have length
|
||
<code>size</code>.</p>
|
||
|
||
<h1 id='panics-11' class='section-header'><a href='#panics-11'>Panics</a></h1>
|
||
<p>Panics if <code>size</code> is 0.</p>
|
||
|
||
<h1 id='example-5' class='section-header'><a href='#example-5'>Example</a></h1>
|
||
<p>Print the slice two elements at a time (i.e. <code>[1,2]</code>,
|
||
<code>[3,4]</code>, <code>[5]</code>):</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='kw-2'>&</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>];
|
||
<span class='kw'>for</span> <span class='ident'>win</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>chunks</span>(<span class='number'>2</span>) {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{:?}"</span>, <span class='ident'>win</span>);
|
||
}</pre>
|
||
</div><h4 id='method.chunks_mut' class='method'><code>fn <a href='#method.chunks_mut' class='fnname'>chunks_mut</a>(&mut self, chunk_size: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='struct' href='../../../bitflags/__core/slice/struct.ChunksMut.html' title='bitflags::__core::slice::ChunksMut'>ChunksMut</a><T></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over <code>chunk_size</code> elements of the slice at a time.
|
||
The chunks are mutable slices, and do not overlap. If <code>chunk_size</code> does
|
||
not divide the length of the slice, then the last chunk will not
|
||
have length <code>chunk_size</code>.</p>
|
||
|
||
<h1 id='panics-12' class='section-header'><a href='#panics-12'>Panics</a></h1>
|
||
<p>Panics if <code>chunk_size</code> is 0.</p>
|
||
</div><h4 id='method.split_at' class='method'><code>fn <a href='#method.split_at' class='fnname'>split_at</a>(&self, mid: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a></code></h4>
|
||
<div class='docblock'><p>Divides one slice into two at an index.</p>
|
||
|
||
<p>The first will contain all indices from <code>[0, mid)</code> (excluding
|
||
the index <code>mid</code> itself) and the second will contain all
|
||
indices from <code>[mid, len)</code> (excluding the index <code>len</code> itself).</p>
|
||
|
||
<h1 id='panics-13' class='section-header'><a href='#panics-13'>Panics</a></h1>
|
||
<p>Panics if <code>mid > len</code>.</p>
|
||
|
||
<h1 id='examples-28' class='section-header'><a href='#examples-28'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>, <span class='number'>20</span>, <span class='number'>50</span>];
|
||
<span class='kw'>let</span> (<span class='ident'>v1</span>, <span class='ident'>v2</span>) <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>split_at</span>(<span class='number'>2</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>([<span class='number'>10</span>, <span class='number'>40</span>], <span class='ident'>v1</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>([<span class='number'>30</span>, <span class='number'>20</span>, <span class='number'>50</span>], <span class='ident'>v2</span>);</pre>
|
||
</div><h4 id='method.split_at_mut' class='method'><code>fn <a href='#method.split_at_mut' class='fnname'>split_at_mut</a>(&mut self, mid: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>(</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a>, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a><a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>)</a></code></h4>
|
||
<div class='docblock'><p>Divides one <code>&mut</code> into two at an index.</p>
|
||
|
||
<p>The first will contain all indices from <code>[0, mid)</code> (excluding
|
||
the index <code>mid</code> itself) and the second will contain all
|
||
indices from <code>[mid, len)</code> (excluding the index <code>len</code> itself).</p>
|
||
|
||
<h1 id='panics-14' class='section-header'><a href='#panics-14'>Panics</a></h1>
|
||
<p>Panics if <code>mid > len</code>.</p>
|
||
|
||
<h1 id='example-6' class='section-header'><a href='#example-6'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>];
|
||
|
||
<span class='comment'>// scoped to restrict the lifetime of the borrows</span>
|
||
{
|
||
<span class='kw'>let</span> (<span class='ident'>left</span>, <span class='ident'>right</span>) <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>split_at_mut</span>(<span class='number'>0</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>left</span> <span class='op'>==</span> []);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>right</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>]);
|
||
}
|
||
|
||
{
|
||
<span class='kw'>let</span> (<span class='ident'>left</span>, <span class='ident'>right</span>) <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>split_at_mut</span>(<span class='number'>2</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>left</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>]);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>right</span> <span class='op'>==</span> [<span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>]);
|
||
}
|
||
|
||
{
|
||
<span class='kw'>let</span> (<span class='ident'>left</span>, <span class='ident'>right</span>) <span class='op'>=</span> <span class='ident'>v</span>.<span class='ident'>split_at_mut</span>(<span class='number'>6</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>left</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>, <span class='number'>6</span>]);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>right</span> <span class='op'>==</span> []);
|
||
}</pre>
|
||
</div><h4 id='method.split' class='method'><code>fn <a href='#method.split' class='fnname'>split</a><F>(&self, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.Split.html' title='bitflags::__core::slice::Split'>Split</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over subslices separated by elements that match
|
||
<code>pred</code>. The matched element is not contained in the subslices.</p>
|
||
|
||
<h1 id='examples-29' class='section-header'><a href='#examples-29'>Examples</a></h1>
|
||
<p>Print the slice split by numbers divisible by 3 (i.e. <code>[10, 40]</code>,
|
||
<code>[20]</code>, <code>[50]</code>):</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>, <span class='number'>20</span>, <span class='number'>60</span>, <span class='number'>50</span>];
|
||
<span class='kw'>for</span> <span class='ident'>group</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>split</span>(<span class='op'>|</span><span class='ident'>num</span><span class='op'>|</span> <span class='op'>*</span><span class='ident'>num</span> <span class='op'>%</span> <span class='number'>3</span> <span class='op'>==</span> <span class='number'>0</span>) {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{:?}"</span>, <span class='ident'>group</span>);
|
||
}</pre>
|
||
</div><h4 id='method.split_mut' class='method'><code>fn <a href='#method.split_mut' class='fnname'>split_mut</a><F>(&mut self, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.SplitMut.html' title='bitflags::__core::slice::SplitMut'>SplitMut</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over mutable subslices separated by elements that
|
||
match <code>pred</code>. The matched element is not contained in the subslices.</p>
|
||
</div><h4 id='method.splitn' class='method'><code>fn <a href='#method.splitn' class='fnname'>splitn</a><F>(&self, n: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.SplitN.html' title='bitflags::__core::slice::SplitN'>SplitN</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over subslices separated by elements that match
|
||
<code>pred</code>, limited to returning at most <code>n</code> items. The matched element is
|
||
not contained in the subslices.</p>
|
||
|
||
<p>The last element returned, if any, will contain the remainder of the
|
||
slice.</p>
|
||
|
||
<h1 id='examples-30' class='section-header'><a href='#examples-30'>Examples</a></h1>
|
||
<p>Print the slice split once by numbers divisible by 3 (i.e. <code>[10, 40]</code>,
|
||
<code>[20, 60, 50]</code>):</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>, <span class='number'>20</span>, <span class='number'>60</span>, <span class='number'>50</span>];
|
||
<span class='kw'>for</span> <span class='ident'>group</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>splitn</span>(<span class='number'>2</span>, <span class='op'>|</span><span class='ident'>num</span><span class='op'>|</span> <span class='op'>*</span><span class='ident'>num</span> <span class='op'>%</span> <span class='number'>3</span> <span class='op'>==</span> <span class='number'>0</span>) {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{:?}"</span>, <span class='ident'>group</span>);
|
||
}</pre>
|
||
</div><h4 id='method.splitn_mut' class='method'><code>fn <a href='#method.splitn_mut' class='fnname'>splitn_mut</a><F>(&mut self, n: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.SplitNMut.html' title='bitflags::__core::slice::SplitNMut'>SplitNMut</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over subslices separated by elements that match
|
||
<code>pred</code>, limited to returning at most <code>n</code> items. The matched element is
|
||
not contained in the subslices.</p>
|
||
|
||
<p>The last element returned, if any, will contain the remainder of the
|
||
slice.</p>
|
||
</div><h4 id='method.rsplitn' class='method'><code>fn <a href='#method.rsplitn' class='fnname'>rsplitn</a><F>(&self, n: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.RSplitN.html' title='bitflags::__core::slice::RSplitN'>RSplitN</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over subslices separated by elements that match
|
||
<code>pred</code> limited to returning at most <code>n</code> items. This starts at the end of
|
||
the slice and works backwards. The matched element is not contained in
|
||
the subslices.</p>
|
||
|
||
<p>The last element returned, if any, will contain the remainder of the
|
||
slice.</p>
|
||
|
||
<h1 id='examples-31' class='section-header'><a href='#examples-31'>Examples</a></h1>
|
||
<p>Print the slice split once, starting from the end, by numbers divisible
|
||
by 3 (i.e. <code>[50]</code>, <code>[10, 40, 30, 20]</code>):</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>, <span class='number'>20</span>, <span class='number'>60</span>, <span class='number'>50</span>];
|
||
<span class='kw'>for</span> <span class='ident'>group</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>rsplitn</span>(<span class='number'>2</span>, <span class='op'>|</span><span class='ident'>num</span><span class='op'>|</span> <span class='op'>*</span><span class='ident'>num</span> <span class='op'>%</span> <span class='number'>3</span> <span class='op'>==</span> <span class='number'>0</span>) {
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{:?}"</span>, <span class='ident'>group</span>);
|
||
}</pre>
|
||
</div><h4 id='method.rsplitn_mut' class='method'><code>fn <a href='#method.rsplitn_mut' class='fnname'>rsplitn_mut</a><F>(&mut self, n: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, pred: F) -> <a class='struct' href='../../../bitflags/__core/slice/struct.RSplitNMut.html' title='bitflags::__core::slice::RSplitNMut'>RSplitNMut</a><T, F> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></span></code></h4>
|
||
<div class='docblock'><p>Returns an iterator over subslices separated by elements that match
|
||
<code>pred</code> limited to returning at most <code>n</code> items. This starts at the end of
|
||
the slice and works backwards. The matched element is not contained in
|
||
the subslices.</p>
|
||
|
||
<p>The last element returned, if any, will contain the remainder of the
|
||
slice.</p>
|
||
</div><h4 id='method.contains' class='method'><code>fn <a href='#method.contains' class='fnname'>contains</a>(&self, x: &T) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><T></span></code></h4>
|
||
<div class='docblock'><p>Returns true if the slice contains an element with the given value.</p>
|
||
|
||
<h1 id='examples-32' class='section-header'><a href='#examples-32'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>contains</span>(<span class='kw-2'>&</span><span class='number'>30</span>));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>contains</span>(<span class='kw-2'>&</span><span class='number'>50</span>));</pre>
|
||
</div><h4 id='method.starts_with' class='method'><code>fn <a href='#method.starts_with' class='fnname'>starts_with</a>(&self, needle: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><T></span></code></h4>
|
||
<div class='docblock'><p>Returns true if <code>needle</code> is a prefix of the slice.</p>
|
||
|
||
<h1 id='examples-33' class='section-header'><a href='#examples-33'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>starts_with</span>(<span class='kw-2'>&</span>[<span class='number'>10</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>starts_with</span>(<span class='kw-2'>&</span>[<span class='number'>10</span>, <span class='number'>40</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>starts_with</span>(<span class='kw-2'>&</span>[<span class='number'>50</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>starts_with</span>(<span class='kw-2'>&</span>[<span class='number'>10</span>, <span class='number'>50</span>]));</pre>
|
||
</div><h4 id='method.ends_with' class='method'><code>fn <a href='#method.ends_with' class='fnname'>ends_with</a>(&self, needle: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><T></span></code></h4>
|
||
<div class='docblock'><p>Returns true if <code>needle</code> is a suffix of the slice.</p>
|
||
|
||
<h1 id='examples-34' class='section-header'><a href='#examples-34'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>10</span>, <span class='number'>40</span>, <span class='number'>30</span>];
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>ends_with</span>(<span class='kw-2'>&</span>[<span class='number'>30</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span>.<span class='ident'>ends_with</span>(<span class='kw-2'>&</span>[<span class='number'>40</span>, <span class='number'>30</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>ends_with</span>(<span class='kw-2'>&</span>[<span class='number'>50</span>]));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='op'>!</span><span class='ident'>v</span>.<span class='ident'>ends_with</span>(<span class='kw-2'>&</span>[<span class='number'>50</span>, <span class='number'>30</span>]));</pre>
|
||
</div><h4 id='method.binary_search' class='method'><code>fn <a href='#method.binary_search' class='fnname'>binary_search</a>(&self, x: &T) -> <a class='enum' href='../../../bitflags/__core/result/enum.Result.html' title='bitflags::__core::result::Result'>Result</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a></span></code></h4>
|
||
<div class='docblock'><p>Binary search a sorted slice for a given element.</p>
|
||
|
||
<p>If the value is found then <code>Ok</code> is returned, containing the
|
||
index of the matching element; if the value is not found then
|
||
<code>Err</code> is returned, containing the index where a matching
|
||
element could be inserted while maintaining sorted order.</p>
|
||
|
||
<h1 id='example-7' class='section-header'><a href='#example-7'>Example</a></h1>
|
||
<p>Looks up a series of four elements. The first is found, with a
|
||
uniquely determined position; the second and third are not
|
||
found; the fourth could match any position in <code>[1,4]</code>.</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>s</span> <span class='op'>=</span> [<span class='number'>0</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>5</span>, <span class='number'>8</span>, <span class='number'>13</span>, <span class='number'>21</span>, <span class='number'>34</span>, <span class='number'>55</span>];
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search</span>(<span class='kw-2'>&</span><span class='number'>13</span>), <span class='prelude-val'>Ok</span>(<span class='number'>9</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search</span>(<span class='kw-2'>&</span><span class='number'>4</span>), <span class='prelude-val'>Err</span>(<span class='number'>7</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search</span>(<span class='kw-2'>&</span><span class='number'>100</span>), <span class='prelude-val'>Err</span>(<span class='number'>13</span>));
|
||
<span class='kw'>let</span> <span class='ident'>r</span> <span class='op'>=</span> <span class='ident'>s</span>.<span class='ident'>binary_search</span>(<span class='kw-2'>&</span><span class='number'>1</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='kw'>match</span> <span class='ident'>r</span> { <span class='prelude-val'>Ok</span>(<span class='number'>1</span>...<span class='number'>4</span>) <span class='op'>=></span> <span class='boolval'>true</span>, _ <span class='op'>=></span> <span class='boolval'>false</span>, });</pre>
|
||
</div><h4 id='method.binary_search_by' class='method'><code>fn <a href='#method.binary_search_by' class='fnname'>binary_search_by</a><F>(&self, f: F) -> <a class='enum' href='../../../bitflags/__core/result/enum.Result.html' title='bitflags::__core::result::Result'>Result</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> <a class='enum' href='../../../bitflags/__core/cmp/enum.Ordering.html' title='bitflags::__core::cmp::Ordering'>Ordering</a></span></code></h4>
|
||
<div class='docblock'><p>Binary search a sorted slice with a comparator function.</p>
|
||
|
||
<p>The comparator function should implement an order consistent
|
||
with the sort order of the underlying slice, returning an
|
||
order code that indicates whether its argument is <code>Less</code>,
|
||
<code>Equal</code> or <code>Greater</code> the desired target.</p>
|
||
|
||
<p>If a matching value is found then returns <code>Ok</code>, containing
|
||
the index for the matched element; if no match is found then
|
||
<code>Err</code> is returned, containing the index where a matching
|
||
element could be inserted while maintaining sorted order.</p>
|
||
|
||
<h1 id='example-8' class='section-header'><a href='#example-8'>Example</a></h1>
|
||
<p>Looks up a series of four elements. The first is found, with a
|
||
uniquely determined position; the second and third are not
|
||
found; the fourth could match any position in <code>[1,4]</code>.</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>s</span> <span class='op'>=</span> [<span class='number'>0</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>5</span>, <span class='number'>8</span>, <span class='number'>13</span>, <span class='number'>21</span>, <span class='number'>34</span>, <span class='number'>55</span>];
|
||
|
||
<span class='kw'>let</span> <span class='ident'>seek</span> <span class='op'>=</span> <span class='number'>13</span>;
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by</span>(<span class='op'>|</span><span class='ident'>probe</span><span class='op'>|</span> <span class='ident'>probe</span>.<span class='ident'>cmp</span>(<span class='kw-2'>&</span><span class='ident'>seek</span>)), <span class='prelude-val'>Ok</span>(<span class='number'>9</span>));
|
||
<span class='kw'>let</span> <span class='ident'>seek</span> <span class='op'>=</span> <span class='number'>4</span>;
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by</span>(<span class='op'>|</span><span class='ident'>probe</span><span class='op'>|</span> <span class='ident'>probe</span>.<span class='ident'>cmp</span>(<span class='kw-2'>&</span><span class='ident'>seek</span>)), <span class='prelude-val'>Err</span>(<span class='number'>7</span>));
|
||
<span class='kw'>let</span> <span class='ident'>seek</span> <span class='op'>=</span> <span class='number'>100</span>;
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by</span>(<span class='op'>|</span><span class='ident'>probe</span><span class='op'>|</span> <span class='ident'>probe</span>.<span class='ident'>cmp</span>(<span class='kw-2'>&</span><span class='ident'>seek</span>)), <span class='prelude-val'>Err</span>(<span class='number'>13</span>));
|
||
<span class='kw'>let</span> <span class='ident'>seek</span> <span class='op'>=</span> <span class='number'>1</span>;
|
||
<span class='kw'>let</span> <span class='ident'>r</span> <span class='op'>=</span> <span class='ident'>s</span>.<span class='ident'>binary_search_by</span>(<span class='op'>|</span><span class='ident'>probe</span><span class='op'>|</span> <span class='ident'>probe</span>.<span class='ident'>cmp</span>(<span class='kw-2'>&</span><span class='ident'>seek</span>));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='kw'>match</span> <span class='ident'>r</span> { <span class='prelude-val'>Ok</span>(<span class='number'>1</span>...<span class='number'>4</span>) <span class='op'>=></span> <span class='boolval'>true</span>, _ <span class='op'>=></span> <span class='boolval'>false</span>, });</pre>
|
||
</div><h4 id='method.binary_search_by_key' class='method'><code>fn <a href='#method.binary_search_by_key' class='fnname'>binary_search_by_key</a><B, F>(&self, b: &B, f: F) -> <a class='enum' href='../../../bitflags/__core/result/enum.Result.html' title='bitflags::__core::result::Result'>Result</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>, <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>> <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> B, B: <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a></span></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>slice_binary_search_by_key</code>)<p>: recently added</p>
|
||
</em></div><div class='docblock'><p>Binary search a sorted slice with a key extraction function.</p>
|
||
|
||
<p>Assumes that the slice is sorted by the key, for instance with
|
||
<code>sort_by_key</code> using the same key extraction function.</p>
|
||
|
||
<p>If a matching value is found then returns <code>Ok</code>, containing the
|
||
index for the matched element; if no match is found then <code>Err</code>
|
||
is returned, containing the index where a matching element could
|
||
be inserted while maintaining sorted order.</p>
|
||
|
||
<h1 id='examples-35' class='section-header'><a href='#examples-35'>Examples</a></h1>
|
||
<p>Looks up a series of four elements in a slice of pairs sorted by
|
||
their second elements. The first is found, with a uniquely
|
||
determined position; the second and third are not found; the
|
||
fourth could match any position in <code>[1,4]</code>.</p>
|
||
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='attribute'>#<span class='op'>!</span>[<span class='ident'>feature</span>(<span class='ident'>slice_binary_search_by_key</span>)]</span>
|
||
<span class='kw'>let</span> <span class='ident'>s</span> <span class='op'>=</span> [(<span class='number'>0</span>, <span class='number'>0</span>), (<span class='number'>2</span>, <span class='number'>1</span>), (<span class='number'>4</span>, <span class='number'>1</span>), (<span class='number'>5</span>, <span class='number'>1</span>), (<span class='number'>3</span>, <span class='number'>1</span>),
|
||
(<span class='number'>1</span>, <span class='number'>2</span>), (<span class='number'>2</span>, <span class='number'>3</span>), (<span class='number'>4</span>, <span class='number'>5</span>), (<span class='number'>5</span>, <span class='number'>8</span>), (<span class='number'>3</span>, <span class='number'>13</span>),
|
||
(<span class='number'>1</span>, <span class='number'>21</span>), (<span class='number'>2</span>, <span class='number'>34</span>), (<span class='number'>4</span>, <span class='number'>55</span>)];
|
||
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by_key</span>(<span class='kw-2'>&</span><span class='number'>13</span>, <span class='op'>|</span><span class='kw-2'>&</span>(<span class='ident'>a</span>,<span class='ident'>b</span>)<span class='op'>|</span> <span class='ident'>b</span>), <span class='prelude-val'>Ok</span>(<span class='number'>9</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by_key</span>(<span class='kw-2'>&</span><span class='number'>4</span>, <span class='op'>|</span><span class='kw-2'>&</span>(<span class='ident'>a</span>,<span class='ident'>b</span>)<span class='op'>|</span> <span class='ident'>b</span>), <span class='prelude-val'>Err</span>(<span class='number'>7</span>));
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>s</span>.<span class='ident'>binary_search_by_key</span>(<span class='kw-2'>&</span><span class='number'>100</span>, <span class='op'>|</span><span class='kw-2'>&</span>(<span class='ident'>a</span>,<span class='ident'>b</span>)<span class='op'>|</span> <span class='ident'>b</span>), <span class='prelude-val'>Err</span>(<span class='number'>13</span>));
|
||
<span class='kw'>let</span> <span class='ident'>r</span> <span class='op'>=</span> <span class='ident'>s</span>.<span class='ident'>binary_search_by_key</span>(<span class='kw-2'>&</span><span class='number'>1</span>, <span class='op'>|</span><span class='kw-2'>&</span>(<span class='ident'>a</span>,<span class='ident'>b</span>)<span class='op'>|</span> <span class='ident'>b</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='kw'>match</span> <span class='ident'>r</span> { <span class='prelude-val'>Ok</span>(<span class='number'>1</span>...<span class='number'>4</span>) <span class='op'>=></span> <span class='boolval'>true</span>, _ <span class='op'>=></span> <span class='boolval'>false</span>, });</pre>
|
||
</div><h4 id='method.sort' class='method'><code>fn <a href='#method.sort' class='fnname'>sort</a>(&mut self) <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a></span></code></h4>
|
||
<div class='docblock'><p>Sorts the slice, in place.</p>
|
||
|
||
<p>This is equivalent to <code>self.sort_by(|a, b| a.cmp(b))</code>.</p>
|
||
|
||
<p>This is a stable sort.</p>
|
||
|
||
<h1 id='examples-36' class='section-header'><a href='#examples-36'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='op'>-</span><span class='number'>5</span>, <span class='number'>4</span>, <span class='number'>1</span>, <span class='op'>-</span><span class='number'>3</span>, <span class='number'>2</span>];
|
||
|
||
<span class='ident'>v</span>.<span class='ident'>sort</span>();
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='op'>-</span><span class='number'>5</span>, <span class='op'>-</span><span class='number'>3</span>, <span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>4</span>]);</pre>
|
||
</div><h4 id='method.sort_by_key' class='method'><span class="since">1.7.0</span><code>fn <a href='#method.sort_by_key' class='fnname'>sort_by_key</a><B, F>(&mut self, f: F) <span class='where'>where B: <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a>, F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T) -> B</span></code></h4>
|
||
<div class='docblock'><p>Sorts the slice, in place, using <code>key</code> to extract a key by which to
|
||
order the sort by.</p>
|
||
|
||
<p>This sort is <code>O(n log n)</code> worst-case and stable, but allocates
|
||
approximately <code>2 * n</code>, where <code>n</code> is the length of <code>self</code>.</p>
|
||
|
||
<p>This is a stable sort.</p>
|
||
|
||
<h1 id='examples-37' class='section-header'><a href='#examples-37'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='op'>-</span><span class='number'>5i32</span>, <span class='number'>4</span>, <span class='number'>1</span>, <span class='op'>-</span><span class='number'>3</span>, <span class='number'>2</span>];
|
||
|
||
<span class='ident'>v</span>.<span class='ident'>sort_by_key</span>(<span class='op'>|</span><span class='ident'>k</span><span class='op'>|</span> <span class='ident'>k</span>.<span class='ident'>abs</span>());
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='op'>-</span><span class='number'>3</span>, <span class='number'>4</span>, <span class='op'>-</span><span class='number'>5</span>]);</pre>
|
||
</div><h4 id='method.sort_by' class='method'><code>fn <a href='#method.sort_by' class='fnname'>sort_by</a><F>(&mut self, compare: F) <span class='where'>where F: <a class='trait' href='../../../bitflags/__core/ops/trait.FnMut.html' title='bitflags::__core::ops::FnMut'>FnMut</a>(&T, &T) -> <a class='enum' href='../../../bitflags/__core/cmp/enum.Ordering.html' title='bitflags::__core::cmp::Ordering'>Ordering</a></span></code></h4>
|
||
<div class='docblock'><p>Sorts the slice, in place, using <code>compare</code> to compare
|
||
elements.</p>
|
||
|
||
<p>This sort is <code>O(n log n)</code> worst-case and stable, but allocates
|
||
approximately <code>2 * n</code>, where <code>n</code> is the length of <code>self</code>.</p>
|
||
|
||
<h1 id='examples-38' class='section-header'><a href='#examples-38'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>v</span> <span class='op'>=</span> [<span class='number'>5</span>, <span class='number'>4</span>, <span class='number'>1</span>, <span class='number'>3</span>, <span class='number'>2</span>];
|
||
<span class='ident'>v</span>.<span class='ident'>sort_by</span>(<span class='op'>|</span><span class='ident'>a</span>, <span class='ident'>b</span><span class='op'>|</span> <span class='ident'>a</span>.<span class='ident'>cmp</span>(<span class='ident'>b</span>));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>, <span class='number'>5</span>]);
|
||
|
||
<span class='comment'>// reverse sorting</span>
|
||
<span class='ident'>v</span>.<span class='ident'>sort_by</span>(<span class='op'>|</span><span class='ident'>a</span>, <span class='ident'>b</span><span class='op'>|</span> <span class='ident'>b</span>.<span class='ident'>cmp</span>(<span class='ident'>a</span>));
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>v</span> <span class='op'>==</span> [<span class='number'>5</span>, <span class='number'>4</span>, <span class='number'>3</span>, <span class='number'>2</span>, <span class='number'>1</span>]);</pre>
|
||
</div><h4 id='method.clone_from_slice' class='method'><span class="since">1.7.0</span><code>fn <a href='#method.clone_from_slice' class='fnname'>clone_from_slice</a>(&mut self, src: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>) <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a></span></code></h4>
|
||
<div class='docblock'><p>Copies the elements from <code>src</code> into <code>self</code>.</p>
|
||
|
||
<p>The length of this slice must be the same as the slice passed in.</p>
|
||
|
||
<h1 id='panics-15' class='section-header'><a href='#panics-15'>Panics</a></h1>
|
||
<p>This function will panic if the two slices have different lengths.</p>
|
||
|
||
<h1 id='example-9' class='section-header'><a href='#example-9'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>dst</span> <span class='op'>=</span> [<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>];
|
||
<span class='kw'>let</span> <span class='ident'>src</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
|
||
<span class='ident'>dst</span>.<span class='ident'>clone_from_slice</span>(<span class='kw-2'>&</span><span class='ident'>src</span>);
|
||
<span class='macro'>assert</span><span class='macro'>!</span>(<span class='ident'>dst</span> <span class='op'>==</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>]);</pre>
|
||
</div><h4 id='method.copy_from_slice' class='method'><span class="since">1.9.0</span><code>fn <a href='#method.copy_from_slice' class='fnname'>copy_from_slice</a>(&mut self, src: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a>) <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/marker/trait.Copy.html' title='bitflags::__core::marker::Copy'>Copy</a></span></code></h4>
|
||
<div class='docblock'><p>Copies all elements from <code>src</code> into <code>self</code>, using a memcpy.</p>
|
||
|
||
<p>The length of <code>src</code> must be the same as <code>self</code>.</p>
|
||
|
||
<h1 id='panics-16' class='section-header'><a href='#panics-16'>Panics</a></h1>
|
||
<p>This function will panic if the two slices have different lengths.</p>
|
||
|
||
<h1 id='example-10' class='section-header'><a href='#example-10'>Example</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>dst</span> <span class='op'>=</span> [<span class='number'>0</span>, <span class='number'>0</span>, <span class='number'>0</span>];
|
||
<span class='kw'>let</span> <span class='ident'>src</span> <span class='op'>=</span> [<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
|
||
|
||
<span class='ident'>dst</span>.<span class='ident'>copy_from_slice</span>(<span class='kw-2'>&</span><span class='ident'>src</span>);
|
||
<span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='ident'>src</span>, <span class='ident'>dst</span>);</pre>
|
||
</div><h4 id='method.to_vec' class='method'><code>fn <a href='#method.to_vec' class='fnname'>to_vec</a>(&self) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a></span></code></h4>
|
||
<div class='docblock'><p>Copies <code>self</code> into a new <code>Vec</code>.</p>
|
||
</div><h4 id='method.into_vec' class='method'><code>fn <a href='#method.into_vec' class='fnname'>into_vec</a>(self: <a class='struct' href='../../../bitflags/__core/boxed/struct.Box.html' title='bitflags::__core::boxed::Box'>Box</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<div class='docblock'><p>Converts <code>self</code> into a vector without clones or allocation.</p>
|
||
</div></div><h2 id='implementations'>Trait Implementations</h2><h3 class='impl'><code>impl<'a> <a class='trait' href='../../../bitflags/__core/convert/trait.From.html' title='bitflags::__core::convert::From'>From</a><&'a <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.str.html'>str</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.u8.html'>u8</a>></code></h3><div class='impl-items'><h4 id='method.from' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(s: &'a <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.str.html'>str</a>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.u8.html'>u8</a>></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, T> <a class='trait' href='../../../bitflags/__core/convert/trait.From.html' title='bitflags::__core::convert::From'>From</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'a [T]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a></span></code></h3><div class='impl-items'><h4 id='method.from-1' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(s: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'a [T]</a>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/convert/trait.AsMut.html' title='bitflags::__core::convert::AsMut'>AsMut</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code><span class="since">1.5.0</span></h3><div class='impl-items'><h4 id='method.as_mut' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.AsMut.html#tymethod.as_mut' class='fnname'>as_mut</a>(&mut self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/convert/trait.AsRef.html' title='bitflags::__core::convert::AsRef'>AsRef</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.as_ref' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.AsRef.html#tymethod.as_ref' class='fnname'>as_ref</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/convert/trait.AsMut.html' title='bitflags::__core::convert::AsMut'>AsMut</a><<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code><span class="since">1.5.0</span></h3><div class='impl-items'><h4 id='method.as_mut-1' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.AsMut.html#tymethod.as_mut' class='fnname'>as_mut</a>(&mut self) -> &mut <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/convert/trait.AsRef.html' title='bitflags::__core::convert::AsRef'>AsRef</a><<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.as_ref-1' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.AsRef.html#tymethod.as_ref' class='fnname'>as_ref</a>(&self) -> &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/fmt/trait.Debug.html' title='bitflags::__core::fmt::Debug'>Debug</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/fmt/trait.Debug.html' title='bitflags::__core::fmt::Debug'>Debug</a></span></code></h3><div class='impl-items'><h4 id='method.fmt' class='method'><code>fn <a href='../../../bitflags/__core/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class='struct' href='../../../bitflags/__core/fmt/struct.Formatter.html' title='bitflags::__core::fmt::Formatter'>Formatter</a>) -> <a class='enum' href='../../../bitflags/__core/result/enum.Result.html' title='bitflags::__core::result::Result'>Result</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.tuple.html'>()</a>, <a class='struct' href='../../../bitflags/__core/fmt/struct.Error.html' title='bitflags::__core::fmt::Error'>Error</a>></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/default/trait.Default.html' title='bitflags::__core::default::Default'>Default</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.default' class='method'><code>fn <a href='../../../bitflags/__core/default/trait.Default.html#tymethod.default' class='fnname'>default</a>() -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Drop.html' title='bitflags::__core::ops::Drop'>Drop</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.drop' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&mut self)</code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.Ord.html' title='bitflags::__core::cmp::Ord'>Ord</a></span></code></h3><div class='impl-items'><h4 id='method.cmp' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&self, other: &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>) -> <a class='enum' href='../../../bitflags/__core/cmp/enum.Ordering.html' title='bitflags::__core::cmp::Ordering'>Ordering</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/cmp/trait.Eq.html' title='bitflags::__core::cmp::Eq'>Eq</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.Eq.html' title='bitflags::__core::cmp::Eq'>Eq</a></span></code></h3><div class='impl-items'></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialOrd.html' title='bitflags::__core::cmp::PartialOrd'>PartialOrd</a><<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialOrd.html' title='bitflags::__core::cmp::PartialOrd'>PartialOrd</a><T></span></code></h3><div class='impl-items'><h4 id='method.partial_cmp' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&self, other: &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>) -> <a class='enum' href='../../../bitflags/__core/option/enum.Option.html' title='bitflags::__core::option::Option'>Option</a><<a class='enum' href='../../../bitflags/__core/cmp/enum.Ordering.html' title='bitflags::__core::cmp::Ordering'>Ordering</a>></code></h4>
|
||
<h4 id='method.lt' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.le' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.gt' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ge' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&self, other: &Rhs) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-1' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-1' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 32]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-2' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-2' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-3' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-3' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 31]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-4' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-4' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-5' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-5' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 30]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-6' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-6' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-7' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-7' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 29]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-8' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-8' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-9' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-9' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 28]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-10' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-10' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-11' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-11' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 27]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-12' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-12' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-13' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-13' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 26]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-14' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-14' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-15' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-15' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 25]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-16' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-16' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-17' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-17' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 24]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-18' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-18' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-19' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-19' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 23]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-20' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-20' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-21' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-21' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 22]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-22' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-22' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-23' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-23' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 21]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-24' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-24' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-25' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-25' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 20]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-26' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-26' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-27' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-27' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 19]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-28' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-28' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-29' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-29' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 18]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-30' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-30' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-31' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-31' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 17]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-32' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-32' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-33' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-33' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 16]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-34' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-34' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-35' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-35' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 15]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-36' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-36' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-37' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-37' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 14]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-38' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-38' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-39' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-39' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 13]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-40' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-40' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-41' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-41' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 12]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-42' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-42' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-43' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-43' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 11]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-44' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-44' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-45' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-45' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 10]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-46' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-46' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-47' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-47' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 9]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-48' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-48' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-49' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-49' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 8]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-50' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-50' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-51' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-51' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 7]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-52' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-52' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-53' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-53' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 6]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-54' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-54' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-55' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-55' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 5]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-56' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-56' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-57' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-57' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 4]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-58' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-58' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-59' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-59' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 3]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-60' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-60' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-61' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-61' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 2]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-62' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-62' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-63' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-63' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 1]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-64' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-64' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &&'b <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-65' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-65' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>[</a>B<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.array.html'>; 0]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b mut [B]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-66' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b mut [B]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-66' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b mut [B]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b [B]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-67' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b [B]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-67' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&'b [B]</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, 'b, A, B> <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><B>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><A> <span class='where'>where A: <a class='trait' href='../../../bitflags/__core/cmp/trait.PartialEq.html' title='bitflags::__core::cmp::PartialEq'>PartialEq</a><B></span></code></h3><div class='impl-items'><h4 id='method.eq-68' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><B>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
<h4 id='method.ne-68' class='method'><code>fn <a href='../../../bitflags/__core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><B>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.bool.html'>bool</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<'a, T> <a class='trait' href='../../../bitflags/__core/iter/trait.Extend.html' title='bitflags::__core::iter::Extend'>Extend</a><&'a T> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/marker/trait.Copy.html' title='bitflags::__core::marker::Copy'>Copy</a> + 'a</span></code><span class="since">1.2.0</span></h3><div class='impl-items'><h4 id='method.extend' class='method'><code>fn <a href='../../../bitflags/__core/iter/trait.Extend.html#tymethod.extend' class='fnname'>extend</a><I>(&mut self, iter: I) <span class='where'>where I: <a class='trait' href='../../../bitflags/__core/iter/trait.IntoIterator.html' title='bitflags::__core::iter::IntoIterator'>IntoIterator</a><Item=&'a T></span></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/iter/trait.Extend.html' title='bitflags::__core::iter::Extend'>Extend</a><T> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.extend-1' class='method'><code>fn <a href='../../../bitflags/__core/iter/trait.Extend.html#tymethod.extend' class='fnname'>extend</a><I>(&mut self, iter: I) <span class='where'>where I: <a class='trait' href='../../../bitflags/__core/iter/trait.IntoIterator.html' title='bitflags::__core::iter::IntoIterator'>IntoIterator</a><Item=T></span></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/iter/trait.IntoIterator.html' title='bitflags::__core::iter::IntoIterator'>IntoIterator</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Item' class='type'><code>type <a href='../../../bitflags/__core/iter/trait.IntoIterator.html#associatedtype.Item' class='type'>Item</a> = T</code></h4>
|
||
<h4 id='associatedtype.IntoIter' class='type'><code>type <a href='../../../bitflags/__core/iter/trait.IntoIterator.html#associatedtype.IntoIter' class='type'>IntoIter</a> = <a class='struct' href='../../../bitflags/__core/vec/struct.IntoIter.html' title='bitflags::__core::vec::IntoIter'>IntoIter</a><T></code></h4>
|
||
<h4 id='method.into_iter' class='method'><code>fn <a href='../../../bitflags/__core/iter/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -> <a class='struct' href='../../../bitflags/__core/vec/struct.IntoIter.html' title='bitflags::__core::vec::IntoIter'>IntoIter</a><T></code></h4>
|
||
<div class='docblock'><p>Creates a consuming iterator, that is, one that moves each value out of
|
||
the vector (from start to end). The vector cannot be used after calling
|
||
this.</p>
|
||
|
||
<h1 id='examples-39' class='section-header'><a href='#examples-39'>Examples</a></h1>
|
||
<pre class='rust rust-example-rendered'>
|
||
<span class='kw'>let</span> <span class='ident'>v</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='string'>"a"</span>.<span class='ident'>to_string</span>(), <span class='string'>"b"</span>.<span class='ident'>to_string</span>()];
|
||
<span class='kw'>for</span> <span class='ident'>s</span> <span class='kw'>in</span> <span class='ident'>v</span>.<span class='ident'>into_iter</span>() {
|
||
<span class='comment'>// s has type String, not &String</span>
|
||
<span class='macro'>println</span><span class='macro'>!</span>(<span class='string'>"{}"</span>, <span class='ident'>s</span>);
|
||
}</pre>
|
||
</div></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/iter/trait.FromIterator.html' title='bitflags::__core::iter::FromIterator'>FromIterator</a><T> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.from_iter' class='method'><code>fn <a href='../../../bitflags/__core/iter/trait.FromIterator.html#tymethod.from_iter' class='fnname'>from_iter</a><I>(iter: I) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where I: <a class='trait' href='../../../bitflags/__core/iter/trait.IntoIterator.html' title='bitflags::__core::iter::IntoIterator'>IntoIterator</a><Item=T></span></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.DerefMut.html' title='bitflags::__core::ops::DerefMut'>DerefMut</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.deref_mut' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.DerefMut.html#tymethod.deref_mut' class='fnname'>deref_mut</a>(&mut self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Deref.html' title='bitflags::__core::ops::Deref'>Deref</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Target' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Deref.html#associatedtype.Target' class='type'>Target</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<h4 id='method.deref' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Deref.html#tymethod.deref' class='fnname'>deref</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeToInclusive.html' title='bitflags::__core::ops::RangeToInclusive'>RangeToInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeToInclusive.html' title='bitflags::__core::ops::RangeToInclusive'>RangeToInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='enum' href='../../../bitflags/__core/ops/enum.RangeInclusive.html' title='bitflags::__core::ops::RangeInclusive'>RangeInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-1' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='enum' href='../../../bitflags/__core/ops/enum.RangeInclusive.html' title='bitflags::__core::ops::RangeInclusive'>RangeInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeFull.html' title='bitflags::__core::ops::RangeFull'>RangeFull</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-2' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, _index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeFull.html' title='bitflags::__core::ops::RangeFull'>RangeFull</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeFrom.html' title='bitflags::__core::ops::RangeFrom'>RangeFrom</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-3' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeFrom.html' title='bitflags::__core::ops::RangeFrom'>RangeFrom</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeTo.html' title='bitflags::__core::ops::RangeTo'>RangeTo</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-4' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeTo.html' title='bitflags::__core::ops::RangeTo'>RangeTo</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='struct' href='../../../bitflags/__core/ops/struct.Range.html' title='bitflags::__core::ops::Range'>Range</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-5' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.Range.html' title='bitflags::__core::ops::Range'>Range</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeToInclusive.html' title='bitflags::__core::ops::RangeToInclusive'>RangeToInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div><h4 id='method.index' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeToInclusive.html' title='bitflags::__core::ops::RangeToInclusive'>RangeToInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='enum' href='../../../bitflags/__core/ops/enum.RangeInclusive.html' title='bitflags::__core::ops::RangeInclusive'>RangeInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-1' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div><h4 id='method.index-1' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='enum' href='../../../bitflags/__core/ops/enum.RangeInclusive.html' title='bitflags::__core::ops::RangeInclusive'>RangeInclusive</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
<div class='stability'><em class='stab unstable'>Unstable (<code>inclusive_range</code>)<p>: recently added, follows RFC</p>
|
||
</em></div></div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeFull.html' title='bitflags::__core::ops::RangeFull'>RangeFull</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-2' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<h4 id='method.index-2' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, _index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeFull.html' title='bitflags::__core::ops::RangeFull'>RangeFull</a>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeFrom.html' title='bitflags::__core::ops::RangeFrom'>RangeFrom</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-3' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<h4 id='method.index-3' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeFrom.html' title='bitflags::__core::ops::RangeFrom'>RangeFrom</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='struct' href='../../../bitflags/__core/ops/struct.RangeTo.html' title='bitflags::__core::ops::RangeTo'>RangeTo</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-4' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<h4 id='method.index-4' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.RangeTo.html' title='bitflags::__core::ops::RangeTo'>RangeTo</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='struct' href='../../../bitflags/__core/ops/struct.Range.html' title='bitflags::__core::ops::Range'>Range</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-5' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a></code></h4>
|
||
<h4 id='method.index-5' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='struct' href='../../../bitflags/__core/ops/struct.Range.html' title='bitflags::__core::ops::Range'>Range</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>>) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.IndexMut.html' title='bitflags::__core::ops::IndexMut'>IndexMut</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.index_mut-6' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&mut self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> &mut T</code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/ops/trait.Index.html' title='bitflags::__core::ops::Index'>Index</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='associatedtype.Output-6' class='type'><code>type <a href='../../../bitflags/__core/ops/trait.Index.html#associatedtype.Output' class='type'>Output</a> = T</code></h4>
|
||
<h4 id='method.index-6' class='method'><code>fn <a href='../../../bitflags/__core/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&self, index: <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.usize.html'>usize</a>) -> &T</code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/hash/trait.Hash.html' title='bitflags::__core::hash::Hash'>Hash</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/hash/trait.Hash.html' title='bitflags::__core::hash::Hash'>Hash</a></span></code></h3><div class='impl-items'><h4 id='method.hash' class='method'><code>fn <a href='../../../bitflags/__core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><H>(&self, state: &mut H) <span class='where'>where H: <a class='trait' href='../../../bitflags/__core/hash/trait.Hasher.html' title='bitflags::__core::hash::Hasher'>Hasher</a></span></code></h4>
|
||
<h4 id='method.hash_slice' class='method'><span class="since">1.3.0</span><code>fn <a href='../../../bitflags/__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/bitflags/primitive.slice.html'>&[Self]</a>, state: &mut H) <span class='where'>where H: <a class='trait' href='../../../bitflags/__core/hash/trait.Hasher.html' title='bitflags::__core::hash::Hasher'>Hasher</a></span></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T> <span class='where'>where T: <a class='trait' href='../../../bitflags/__core/clone/trait.Clone.html' title='bitflags::__core::clone::Clone'>Clone</a></span></code></h3><div class='impl-items'><h4 id='method.clone' class='method'><code>fn <a href='../../../bitflags/__core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h4>
|
||
<h4 id='method.clone_from' class='method'><code>fn <a href='../../../bitflags/__core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, other: &<a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T>)</code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/borrow/trait.BorrowMut.html' title='bitflags::__core::borrow::BorrowMut'>BorrowMut</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.borrow_mut' class='method'><code>fn <a href='../../../bitflags/__core/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&mut self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&mut [T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/borrow/trait.Borrow.html' title='bitflags::__core::borrow::Borrow'>Borrow</a><<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>[</a>T<a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>]</a>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.borrow' class='method'><code>fn <a href='../../../bitflags/__core/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&self) -> <a class='primitive' href='https://doc.rust-lang.org/nightly/bitflags/primitive.slice.html'>&[T]</a></code></h4>
|
||
</div><h3 class='impl'><code>impl<T> <a class='trait' href='../../../bitflags/__core/convert/trait.From.html' title='bitflags::__core::convert::From'>From</a><<a class='struct' href='../../../bitflags/__core/collections/binary_heap/struct.BinaryHeap.html' title='bitflags::__core::collections::binary_heap::BinaryHeap'>BinaryHeap</a><T>> for <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></code></h3><div class='impl-items'><h4 id='method.from-2' class='method'><code>fn <a href='../../../bitflags/__core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(heap: <a class='struct' href='../../../bitflags/__core/collections/binary_heap/struct.BinaryHeap.html' title='bitflags::__core::collections::binary_heap::BinaryHeap'>BinaryHeap</a><T>) -> <a class='struct' href='../../../bitflags/__core/vec/struct.Vec.html' title='bitflags::__core::vec::Vec'>Vec</a><T></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 = "bitflags";
|
||
window.playgroundUrl = "";
|
||
</script>
|
||
<script src="../../../jquery.js"></script>
|
||
<script src="../../../main.js"></script>
|
||
|
||
<script defer src="../../../search-index.js"></script>
|
||
</body>
|
||
</html> |