Struct tindex::TVec

#[repr(transparent)]
pub struct TVec<I, T> { /* fields omitted */ }

Implementations

impl<I, T> TVec<I, T>

pub fn new() -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn from_vec(vec: Vec<T>) -> Self

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

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

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

pub fn extend_from_slice(&mut self, other: &TSlice<I, T>) where
    T: Clone, 

pub fn append(&mut self, other: &mut Self)

impl<I: TIndex, T> TVec<I, T>

pub fn push(&mut self, item: T) -> I

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

pub fn remove(&mut self, id: I) -> T

pub fn splice<R, E>(
    &mut self,
    range: R,
    replace_with: E
) -> Splice<'_, E::IntoIter> where
    R: RangeBounds<I>,
    E: IntoIterator<Item = T>, 

pub fn split_off(&mut self, at: I) -> Self

Methods from Deref<Target = TSlice<I, T>>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

pub fn first(&self) -> Option<&T>

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

pub fn last(&self) -> Option<&T>

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

pub fn split_last(&self) -> Option<(&T, &Self)>

pub fn contains(&self, item: &T) -> bool where
    T: PartialEq<T>, 

pub fn iter<'a>(&'a self) -> Iter<'a, T>

pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T>

pub fn to_slice<'a>(&'a self) -> &'a [T]

pub fn sort(&mut self) where
    T: Ord, 

pub fn sort_by<F>(&mut self, compare: F) where
    F: FnMut(&T, &T) -> Ordering, 

pub fn sort_by_key<K, F>(&mut self, f: F) where
    F: FnMut(&T) -> K,
    K: Ord, 

pub fn sort_by_cached_key<K, F>(&mut self, f: F) where
    F: FnMut(&T) -> K,
    K: Ord, 

pub fn windows(&self, size: usize) -> Windows<'_, T>

pub fn get(&self, idx: I) -> Option<&T>

pub fn get_mut(&mut self, idx: I) -> Option<&mut T>

pub fn last_id(&self) -> Option<I>

pub fn range_start(&self) -> I

pub fn range_end(&self) -> I

pub fn index_iter(&self) -> IndexIter<I>

pub fn swap(&mut self, a: I, b: I)

pub fn split_at(&self, mid: I) -> (&Self, &Self)

pub fn split_at_mut(&mut self, mid: I) -> (&mut Self, &mut Self)

pub fn binary_search(&self, x: &T) -> Result<I, I> where
    T: Ord, 

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<I, I> where
    F: FnMut(&'a T) -> Ordering, 

pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<I, I> where
    F: FnMut(&'a T) -> B,
    B: Ord, 

Trait Implementations

impl<I, T> AsMut<TSlice<I, T>> for TVec<I, T>

fn as_mut(&mut self) -> &mut TSlice<I, T>

Performs the conversion.

impl<I, T> AsRef<TSlice<I, T>> for TVec<I, T>

fn as_ref(&self) -> &TSlice<I, T>

Performs the conversion.

impl<I, T> Borrow<TSlice<I, T>> for TVec<I, T>

fn borrow(&self) -> &TSlice<I, T>

Immutably borrows from an owned value.

impl<I, T> BorrowMut<TSlice<I, T>> for TVec<I, T>

fn borrow_mut(&mut self) -> &mut TSlice<I, T>

Mutably borrows from an owned value.

impl<I, T: Clone> Clone for TVec<I, T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, T: Debug> Debug for TVec<I, T>

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

Formats the value using the given formatter.

impl<I, T> Default for TVec<I, T>

fn default() -> Self

Returns the “default value” for a type.

impl<I, T> Deref for TVec<I, T>

type Target = TSlice<I, T>

The resulting type after dereferencing.

fn deref<'a>(&'a self) -> &'a TSlice<I, T>

Dereferences the value.

impl<I, T> DerefMut for TVec<I, T>

fn deref_mut<'a>(&'a mut self) -> &'a mut TSlice<I, T>

Mutably dereferences the value.

impl<I, T> Extend<T> for TVec<I, T>

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

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<'a, I, T: Clone> From<&'a [T]> for TVec<I, T>

fn from(slice: &'a [T]) -> Self

Performs the conversion.

impl<'a, I, T: Clone> From<&'a TSlice<I, T>> for TVec<I, T>

fn from(slice: &'a TSlice<I, T>) -> Self

Performs the conversion.

impl<'a, I, T> From<&'a Vec<T, Global>> for &'a TVec<I, T>

fn from(vec: &'a Vec<T>) -> Self

Performs the conversion.

impl<'a, I, T: Clone> From<&'a mut [T]> for TVec<I, T>

fn from(slice: &'a mut [T]) -> Self

Performs the conversion.

impl<'a, I, T: Clone> From<&'a mut TSlice<I, T>> for TVec<I, T>

fn from(slice: &'a mut TSlice<I, T>) -> Self

Performs the conversion.

impl<'a, I, T> From<&'a mut Vec<T, Global>> for &'a mut TVec<I, T>

fn from(vec: &'a mut Vec<T>) -> Self

Performs the conversion.

impl<I, T> From<Vec<T, Global>> for TVec<I, T>

fn from(vec: Vec<T>) -> Self

Performs the conversion.

impl<I, T> FromIterator<T> for TVec<I, T>

fn from_iter<U: IntoIterator<Item = T>>(iter: U) -> TVec<I, T>

Creates a value from an iterator.

impl<I, T: Hash> Hash for TVec<I, T>

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

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<I, T> IntoIterator for TVec<I, 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, I, T> IntoIterator for &'a TVec<I, 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, I, T> IntoIterator for &'a mut TVec<I, 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<I, T: PartialEq> PartialEq<TVec<I, T>> for TVec<I, T>

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<I, T: Eq> Eq for TVec<I, T>