Struct thin_vec::ThinVec

#[repr(C)]pub struct ThinVec<T> { /* fields omitted */ }

See the crate's top level documentation for a description of this type.

Implementations

impl<T> ThinVec<T>

pub fn new() -> ThinVec<T>

pub fn with_capacity(cap: usize) -> ThinVec<T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub unsafe fn set_len(&mut self, len: usize)

pub fn push(&mut self, val: T)

pub fn pop(&mut self) -> Option<T>

pub fn insert(&mut self, idx: usize, elem: T)

pub fn remove(&mut self, idx: usize) -> T

pub fn swap_remove(&mut self, idx: usize) -> T

pub fn truncate(&mut self, len: usize)

pub fn clear(&mut self)

pub fn as_slice(&self) -> &[T]

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn reserve(&mut self, additional: usize)

Reserve capacity for at least additional more elements to be inserted.

May reserve more space than requested, to avoid frequent reallocations.

Panics if the new capacity overflows usize.

Re-allocates only if self.capacity() < self.len() + additional.

pub fn reserve_exact(&mut self, additional: usize)

Reserves the minimum capacity for additional more elements to be inserted.

Panics if the new capacity overflows usize.

Re-allocates only if self.capacity() < self.len() + additional.

pub fn shrink_to_fit(&mut self)

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&T) -> bool, 

Retains only the elements specified by the predicate.

In other words, remove all elements e such that f(&e) returns false. This method operates in place and preserves the order of the retained elements.

Examples

let mut vec = thin_vec![1, 2, 3, 4];
vec.retain(|&x| x%2 == 0);
assert_eq!(vec, [2, 4]);

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut T) -> K,
    K: PartialEq<K>, 

Removes consecutive elements in the vector that resolve to the same key.

If the vector is sorted, this removes all duplicates.

Examples

let mut vec = thin_vec![10, 20, 21, 30, 20];

vec.dedup_by_key(|i| *i / 10);

assert_eq!(vec, [10, 20, 30, 20]);

pub fn dedup_by<F>(&mut self, same_bucket: F) where
    F: FnMut(&mut T, &mut T) -> bool, 

Removes consecutive elements in the vector according to a predicate.

The same_bucket function is passed references to two elements from the vector, and returns true if the elements compare equal, or false if they do not. Only the first of adjacent equal items is kept.

If the vector is sorted, this removes all duplicates.

Examples

let mut vec = thin_vec!["foo", "bar", "Bar", "baz", "bar"];

vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(vec, ["foo", "bar", "baz", "bar"]);

pub fn split_off(&mut self, at: usize) -> ThinVec<T>

pub fn append(&mut self, other: &mut ThinVec<T>)

pub fn drain<R>(&mut self, range: R) -> Drain<'_, T> where
    R: RangeBounds<usize>, 

impl<T: Clone> ThinVec<T>

pub fn resize(&mut self, new_len: usize, value: T)

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.

Examples

let mut vec = thin_vec!["hello"];
vec.resize(3, "world");
assert_eq!(vec, ["hello", "world", "world"]);

let mut vec = thin_vec![1, 2, 3, 4];
vec.resize(2, 0);
assert_eq!(vec, [1, 2]);

pub fn extend_from_slice(&mut self, other: &[T])

impl<T: PartialEq> ThinVec<T>

pub fn dedup(&mut self)

Removes consecutive repeated elements in the vector.

If the vector is sorted, this removes all duplicates.

Examples

let mut vec = thin_vec![1, 2, 2, 3, 2];

vec.dedup();

assert_eq!(vec, [1, 2, 3, 2]);

Trait Implementations

impl<T> AsRef<[T]> for ThinVec<T>

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T> Borrow<[T]> for ThinVec<T>

fn borrow(&self) -> &[T]

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for ThinVec<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T> Clone for ThinVec<T> where
    T: Clone, 

fn clone(&self) -> ThinVec<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ThinVec<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for ThinVec<T>

fn default() -> ThinVec<T>

Returns the "default value" for a type.

impl<T> Deref for ThinVec<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T> DerefMut for ThinVec<T>

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T> Drop for ThinVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Eq for ThinVec<T> where
    T: Eq, 

impl<T> Extend<T> for ThinVec<T>

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> FromIterator<T> for ThinVec<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> ThinVec<T>

Creates a value from an iterator.

impl<T> Hash for ThinVec<T> where
    T: Hash, 

fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T> IntoIterator for ThinVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a ThinVec<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) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut ThinVec<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) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T> Ord for ThinVec<T> where
    T: Ord, 

fn cmp(&self, other: &ThinVec<T>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'a, A, B> PartialEq<&'a [B; 0]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 0]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 0]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 1]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 1]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 10]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 10]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 10]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 11]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 11]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 11]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 12]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 12]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 12]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 13]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 13]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 13]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 14]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 14]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 14]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 15]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 15]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 15]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 16]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 16]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 16]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 17]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 17]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 17]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 18]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 18]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 18]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 19]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 19]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 19]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 2]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 2]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 2]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 20]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 20]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 20]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 21]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 21]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 21]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 22]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 22]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 22]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 23]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 23]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 23]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 24]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 24]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 24]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 25]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 25]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 25]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 26]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 26]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 26]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 27]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 27]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 27]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 28]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 28]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 28]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 29]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 29]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 29]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 3]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 3]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 3]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 30]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 30]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 30]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 31]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 31]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 31]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 32]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 32]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 32]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 4]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 4]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 4]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 5]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 5]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 5]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 6]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 6]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 6]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 7]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 7]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 7]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 8]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 8]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B; 9]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B; 9]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B; 9]) -> bool

This method tests for !=.

impl<'a, A, B> PartialEq<&'a [B]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &&'a [B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &&'a [B]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 0]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 0]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 0]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 1]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 1]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 1]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 10]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 10]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 10]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 11]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 11]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 11]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 12]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 12]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 12]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 13]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 13]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 13]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 14]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 14]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 14]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 15]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 15]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 15]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 16]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 16]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 16]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 17]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 17]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 17]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 18]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 18]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 18]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 19]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 19]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 19]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 2]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 2]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 2]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 20]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 20]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 20]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 21]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 21]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 21]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 22]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 22]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 22]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 23]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 23]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 23]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 24]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 24]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 24]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 25]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 25]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 25]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 26]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 26]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 26]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 27]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 27]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 27]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 28]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 28]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 28]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 29]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 29]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 29]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 3]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 3]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 3]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 30]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 30]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 30]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 31]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 31]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 31]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 32]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 32]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 32]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 4]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 4]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 4]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 5]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 5]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 5]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 6]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 6]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 6]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 7]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 7]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 7]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 8]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 8]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 8]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B; 9]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B; 9]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B; 9]) -> bool

This method tests for !=.

impl<A, B> PartialEq<[B]> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &[B]) -> bool

This method tests for !=.

impl<A, B> PartialEq<ThinVec<B>> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &ThinVec<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ThinVec<B>) -> bool

This method tests for !=.

impl<A, B> PartialEq<Vec<B>> for ThinVec<A> where
    A: PartialEq<B>, 

fn eq(&self, other: &Vec<B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vec<B>) -> bool

This method tests for !=.

impl<T> PartialOrd<ThinVec<T>> for ThinVec<T> where
    T: PartialOrd, 

fn partial_cmp(&self, other: &ThinVec<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Write for ThinVec<u8>

Write is implemented for ThinVec<u8> by appending to the vector. The vector will grow as needed. This implementation is identical to the one for Vec<u8>.

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn write_all(&mut self, buf: &[u8]) -> Result<()>

Attempts to write an entire buffer into this writer.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬 This is a nightly-only experimental API. (can_vector)

Determines if this Writeer has an efficient write_vectored implementation.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬 This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

Creates a "by reference" adaptor for this instance of Write.