Struct heapless::Vec [−][src]
A fixed capacity Vec
Examples
use heapless::Vec; use heapless::consts::*; // A vector with a fixed capacity of 8 elements allocated on the stack let mut vec = Vec::<_, U8>::new(); vec.push(1); vec.push(2); assert_eq!(vec.len(), 2); assert_eq!(vec[0], 1); assert_eq!(vec.pop(), Some(2)); assert_eq!(vec.len(), 1); vec[0] = 7; assert_eq!(vec[0], 7); vec.extend([1, 2, 3].iter().cloned()); for x in &vec { println!("{}", x); } assert_eq!(vec, [7, 1, 2, 3]);
Implementations
impl<T, N> Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
pub fn new() -> Self
[src]
Constructs a new, empty vector with a fixed capacity of N
Examples
use heapless::Vec; use heapless::consts::*; // allocate the vector on the stack let mut x: Vec<u8, U16> = Vec::new(); // allocate the vector in a static variable static mut X: Vec<u8, U16> = Vec(heapless::i::Vec::new());
pub fn from_slice(other: &[T]) -> Result<Self, ()> where
T: Clone,
[src]
T: Clone,
Constructs a new vector with a fixed capacity of N
and fills it
with the provided slice.
This is equivalent to the following code:
use heapless::Vec; use heapless::consts::*; let mut v: Vec<u8, U16> = Vec::new(); v.extend_from_slice(&[1, 2, 3]).unwrap();
pub fn capacity(&self) -> usize
[src]
Returns the maximum number of elements the vector can hold
pub fn clear(&mut self)
[src]
Clears the vector, removing all values.
pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()> where
T: Clone,
[src]
T: Clone,
Clones and appends all elements in a slice to the Vec
.
Iterates over the slice other
, clones each element, and then appends
it to this Vec
. The other
vector is traversed in-order.
Examples
use heapless::Vec; use heapless::consts::*; let mut vec = Vec::<u8, U8>::new(); vec.push(1).unwrap(); vec.extend_from_slice(&[2, 3, 4]).unwrap(); assert_eq!(*vec, [1, 2, 3, 4]);
pub fn pop(&mut self) -> Option<T>
[src]
Removes the last element from a vector and return it, or None
if it’s empty
pub fn push(&mut self, item: T) -> Result<(), T>
[src]
Appends an item
to the back of the collection
Returns back the item
if the vector is full
pub fn truncate(&mut self, len: usize)
[src]
Shortens the vector, keeping the first len
elements and dropping the rest.
pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()> where
T: Clone,
[src]
T: Clone,
Resizes the Vec in-place so that len is equal to new_len.
If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value. If new_len is less than len, the Vec is simply truncated.
See also resize_default
.
pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()> where
T: Clone + Default,
[src]
T: Clone + Default,
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with Default::default()
.
If new_len
is less than len
, the Vec
is simply truncated.
See also resize
.
pub unsafe fn set_len(&mut self, new_len: usize)
[src]
Forces the length of the vector to new_len
.
This is a low-level operation that maintains none of the normal
invariants of the type. Normally changing the length of a vector
is done using one of the safe operations instead, such as
truncate
, resize
, extend
, or clear
.
Safety
new_len
must be less than or equal tocapacity()
.- The elements at
old_len..new_len
must be initialized.
Examples
This method can be useful for situations in which the vector is serving as a buffer for other code, particularly over FFI:
use heapless::Vec; use heapless::consts::*; pub fn get_dictionary(&self) -> Option<Vec<u8, U32768>> { // Per the FFI method's docs, "32768 bytes is always enough". let mut dict = Vec::new(); let mut dict_length = 0; // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that: // 1. `dict_length` elements were initialized. // 2. `dict_length` <= the capacity (32_768) // which makes `set_len` safe to call. unsafe { // Make the FFI call... let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length); if r == Z_OK { // ...and update the length to what was initialized. dict.set_len(dict_length); Some(dict) } else { None } } }
While the following example is sound, there is a memory leak since
the inner vectors were not freed prior to the set_len
call:
use core::iter::FromIterator; use heapless::Vec; use heapless::consts::*; let mut vec = Vec::<Vec<u8, U3>, U3>::from_iter( [ Vec::from_iter([1, 0, 0].iter().cloned()), Vec::from_iter([0, 1, 0].iter().cloned()), Vec::from_iter([0, 0, 1].iter().cloned()), ] .iter() .cloned() ); // SAFETY: // 1. `old_len..0` is empty so no elements need to be initialized. // 2. `0 <= capacity` always holds whatever `capacity` is. unsafe { vec.set_len(0); }
Normally, here, one would use clear
instead to correctly drop
the contents and thus not leak memory.
pub fn swap_remove(&mut self, index: usize) -> T
[src]
Removes an element from the vector and returns it.
The removed element is replaced by the last element of the vector.
This does not preserve ordering, but is O(1).
Panics
Panics if index
is out of bounds.
Examples
use heapless::Vec; use heapless::consts::*; let mut v: Vec<_, U8> = Vec::new(); v.push("foo").unwrap(); v.push("bar").unwrap(); v.push("baz").unwrap(); v.push("qux").unwrap(); assert_eq!(v.swap_remove(1), "bar"); assert_eq!(&*v, ["foo", "qux", "baz"]); assert_eq!(v.swap_remove(0), "foo"); assert_eq!(&*v, ["baz", "qux"]);
pub fn starts_with(&self, needle: &[T]) -> bool where
T: PartialEq,
[src]
T: PartialEq,
Returns true
if needle
is a prefix of the Vec.
Always returns true
if needle
is an empty slice.
Examples
use heapless::Vec; use heapless::consts::*; let v: Vec<_, U8> = Vec::from_slice(b"abc").unwrap(); assert_eq!(v.starts_with(b""), true); assert_eq!(v.starts_with(b"ab"), true); assert_eq!(v.starts_with(b"bc"), false);
pub fn ends_with(&self, needle: &[T]) -> bool where
T: PartialEq,
[src]
T: PartialEq,
Returns true
if needle
is a suffix of the Vec.
Always returns true
if needle
is an empty slice.
Examples
use heapless::Vec; use heapless::consts::*; let v: Vec<_, U8> = Vec::from_slice(b"abc").unwrap(); assert_eq!(v.ends_with(b""), true); assert_eq!(v.ends_with(b"ab"), false); assert_eq!(v.ends_with(b"bc"), true);
Trait Implementations
impl<T, N> AsMut<[T]> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> AsMut<Vec<T, N>> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> AsRef<[T]> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> AsRef<Vec<T, N>> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> Clone for Vec<T, N> where
N: ArrayLength<T>,
T: Clone,
[src]
N: ArrayLength<T>,
T: Clone,
fn clone(&self) -> Self
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T, N> Debug for Vec<T, N> where
T: Debug,
N: ArrayLength<T>,
[src]
T: Debug,
N: ArrayLength<T>,
impl<T, N> Default for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> Deref for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> DerefMut for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> Drop for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
impl<T, N> Eq for Vec<T, N> where
N: ArrayLength<T>,
T: Eq,
[src]
N: ArrayLength<T>,
T: Eq,
impl<'a, T, N> Extend<&'a T> for Vec<T, N> where
T: 'a + Copy,
N: ArrayLength<T>,
[src]
T: 'a + Copy,
N: ArrayLength<T>,
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = &'a T>,
[src]
I: IntoIterator<Item = &'a T>,
pub fn extend_one(&mut self, item: A)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<T, N> Extend<T> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
pub fn extend_one(&mut self, item: A)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
impl<T, N> FromIterator<T> for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
fn from_iter<I>(iter: I) -> Self where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T, N> Hash for Vec<T, N> where
T: Hash,
N: ArrayLength<T>,
[src]
T: Hash,
N: ArrayLength<T>,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<T, N> Hash for Vec<T, N> where
T: Hash,
N: ArrayLength<T>,
[src]
T: Hash,
N: ArrayLength<T>,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
[src]
H: Hasher,
impl<'a, T, N> IntoIterator for &'a Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, T, N> IntoIterator for &'a mut Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type Item = &'a mut T
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<T, N> IntoIterator for Vec<T, N> where
N: ArrayLength<T>,
[src]
N: ArrayLength<T>,
type Item = T
The type of the elements being iterated over.
type IntoIter = IntoIter<T, N>
Which kind of iterator are we turning this into?
fn into_iter(self) -> Self::IntoIter
[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 0]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 0]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 1]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 1]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 10]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 10]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 11]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 11]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 12]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 12]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 13]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 13]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 14]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 14]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 15]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 15]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 16]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 16]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 17]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 17]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 18]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 18]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 19]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 19]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 2]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 2]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 20]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 20]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 21]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 21]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 22]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 22]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 23]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 23]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 24]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 24]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 25]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 25]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 26]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 26]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 27]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 27]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 28]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 28]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 29]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 29]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 3]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 3]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 30]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 30]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 31]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 31]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 32]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 32]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 4]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 4]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 5]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 5]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 6]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 6]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 7]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 7]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 8]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 8]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B; 9]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B; 9]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a [B]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a [B]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<&'a mut [B]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &&'a mut [B]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 0]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 1]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 10]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 10]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 11]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 11]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 12]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 12]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 13]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 13]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 14]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 14]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 15]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 15]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 16]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 16]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 17]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 17]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 18]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 18]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 19]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 19]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 2]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 20]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 20]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 21]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 21]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 22]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 22]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 23]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 23]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 24]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 24]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 25]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 25]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 26]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 26]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 27]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 27]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 28]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 28]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 29]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 29]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 3]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 30]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 30]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 31]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 31]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 32]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
fn eq(&self, other: &[B; 32]) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<'a, 'b, A, B, N> PartialEq<[B; 4]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 5]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 6]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 7]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 8]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B; 9]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<'a, 'b, A, B, N> PartialEq<[B]> for Vec<A, N> where
A: PartialEq<B>,
N: ArrayLength<A>,
[src]
A: PartialEq<B>,
N: ArrayLength<A>,
impl<A, B, N1, N2> PartialEq<Vec<B, N2>> for Vec<A, N1> where
N1: ArrayLength<A>,
N2: ArrayLength<B>,
A: PartialEq<B>,
[src]
N1: ArrayLength<A>,
N2: ArrayLength<B>,
A: PartialEq<B>,
fn eq(&self, other: &Vec<B, N2>) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
impl<N> Write for Vec<u8, N> where
N: ArrayLength<u8>,
[src]
N: ArrayLength<u8>,
Auto Trait Implementations
impl<T, N> Send for Vec<T, N> where
T: Send,
T: Send,
impl<T, N> Sync for Vec<T, N> where
T: Sync,
T: Sync,
impl<T, N> Unpin for Vec<T, N> where
<N as ArrayLength<T>>::ArrayType: Unpin,
<N as ArrayLength<T>>::ArrayType: Unpin,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,