Struct tsil_cev::TsilCev

pub struct TsilCev<T> { /* fields omitted */ }

Implementations

impl<T> TsilCev<T>

pub fn with_capacity(cap: usize) -> Self

Constructs a new, empty TsilCev with the specified capacity like in Vec.

use tsil_cev::TsilCev;

let tc = TsilCev::<()>::with_capacity(4);
assert_eq!(tc.len(), 0);
assert_eq!(tc.capacity(), 4);

pub const fn new() -> Self

Constructs a new, empty TsilCev.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
assert_eq!(tc.len(), 0);
assert_eq!(tc.capacity(), 0);

tc.push_back(5);
assert_eq!(tc.len(), 1);
assert!(tc.capacity() >= 1);

pub fn clear(&mut self)

Deletes all values from TsilCev like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3]);
assert_eq!(tc.len(), 4);
assert!(tc.capacity() >= 4);

tc.clear();
assert_eq!(tc.len(), 0);

pub fn iter_tsil(&self) -> TsilIter<'_, T>

Returns Tsil iterator. Iterating as in LinkedList.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_back(10);
tc.push_front(0);
let mut cev_iter = tc.iter_tsil();

assert_eq!(cev_iter.next(), Some(&0));
assert_eq!(cev_iter.next(), Some(&10));
assert_eq!(cev_iter.next(), None);

pub fn iter_tsil_mut(&mut self) -> TsilIterMut<'_, T>

Returns Tsil iterator. Iterating as in LinkedList that allows modifying each value.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_back(10);
tc.push_front(0);
for x in tc.iter_tsil_mut() {
    *x *= 20;
}

assert_eq!(tc.into_vec(), &[0, 200]);

pub fn iter_cev(&self) -> CevIter<'_, T>

Returns Cev iterator. Iterating as in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_back(10);
tc.push_front(0);
let mut cev_iter = tc.iter_cev();

assert_eq!(cev_iter.next(), Some(&10));
assert_eq!(cev_iter.next(), Some(&0));
assert_eq!(cev_iter.next(), None);

pub fn iter_cev_mut(&mut self) -> CevIterMut<'_, T>

Returns Cev iterator. Iterating as in Vec that allows modifying each value.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_back(10);
tc.push_front(0);
for x in tc.iter_cev_mut() {
    *x *= 20;
}

assert_eq!(tc.into_vec(), &[0, 200]);

pub fn drain_filter_tsil<F>(&mut self, pred: F) -> DrainFilterTsil<'_, T, F> where
    F: FnMut(&mut T) -> bool, 

Creates an Tsil iterator which uses a mutate closure to determine if an element should be removed like in LinkedList.

If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the TsilCev and will not be yielded by the iterator.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(4);
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_front(0);
tc.push_back(5);
tc.push_back(6);
tc.push_back(7);
tc.push_back(8);
tc.push_back(9);

let less_eq_four = tc.drain_filter_tsil(|x| *x <= 4).collect::<Vec<_>>();

assert_eq!(less_eq_four, &[0, 1, 2, 3, 4]); // note the order of the sequence (Tsil iterator)
assert_eq!(tc.into_vec(), &[5, 6, 7, 8, 9]);

pub fn drain_filter_cev<F>(&mut self, pred: F) -> DrainFilterCev<'_, T, F> where
    F: FnMut(&mut T) -> bool, 

More efficient then drain_filter_tsil because use Cev iterator. But the iteration order is not the same as in LinkedList. Creates an Cev iterator which uses a mutate closure to determine if an element should be removed like in Vec.

If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the TsilCev and will not be yielded by the iterator.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(4);
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_front(0);
tc.push_back(5);
tc.push_back(6);
tc.push_back(7);
tc.push_back(8);
tc.push_back(9);

let less_eq_four = tc.drain_filter_cev(|x| *x <= 4).collect::<Vec<_>>();

assert_eq!(less_eq_four, &[4, 3, 2, 1, 0]); // note the order of the sequence (Cev iterator)
assert_eq!(tc.into_vec(), &[5, 6, 7, 8, 9]);

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

Returns reference to the front (start) element or None if TsilCev is empty like in LinkedList.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
assert_eq!(tc.front(), Some(&0));
assert_eq!(TsilCev::<()>::new().front(), None);

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

Returns reference to the back (end) element or None if TsilCev is empty like in LinkedList.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
assert_eq!(tc.back(), Some(&4));
assert_eq!(TsilCev::<()>::new().back(), None);

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

Returns mutable reference to the front (start) element or None if TsilCev is empty like in LinkedList.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
match tc.front_mut() {
    Some(x) => *x = 10,
    None => {},
}

assert_eq!(tc.front(), Some(&10));
assert_eq!(TsilCev::<()>::new().front(), None);

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

Returns mutable reference to the back (end) element or None if TsilCev is empty like in LinkedList.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
match tc.back_mut() {
    Some(x) => *x = 14,
    None => {},
}

assert_eq!(tc.back(), Some(&14));
assert_eq!(TsilCev::<()>::new().back(), None);

pub fn cursor_front(&self) -> Cursor<'_, T>

Returns cursor to the front (start) element.

use tsil_cev::TsilCev;

let tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
let cursor = tc.cursor_front();

assert_eq!(cursor.current(), tc.front());

pub fn cursor_back(&self) -> Cursor<'_, T>

Returns cursor to the end (back) element.

use tsil_cev::TsilCev;

let tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
let cursor = tc.cursor_back();

assert_eq!(cursor.current(), tc.back());

pub fn cursor_front_mut(&mut self) -> CursorMut<'_, T>

Returns mutable cursor to the front (start) element.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
let mut cursor = tc.cursor_front_mut();
if let Some(x) = cursor.current_mut() {
    *x = 14;
}

assert_eq!(cursor.current(), Some(&14));
assert_eq!(tc.into_vec(), &[14, 1, 2, 3, 4]);

pub fn cursor_back_mut(&mut self) -> CursorMut<'_, T>

Returns mutable cursor to the back (end) element.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
let mut cursor = tc.cursor_back_mut();
if let Some(x) = cursor.current_mut() {
    *x = 14;
}

assert_eq!(cursor.current(), Some(&14));
assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 14]);

pub fn cursor_idx_tsil(&self, idx: usize) -> Cursor<'_, T>

Returns cursor to the element with LinkedList order.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_back(4);

assert_eq!(tc.cursor_idx_tsil(0).current(), Some(&1));
assert_eq!(tc.cursor_idx_tsil(1).current(), Some(&2));
assert_eq!(tc.cursor_idx_tsil(2).current(), Some(&3));
assert_eq!(tc.cursor_idx_tsil(3).current(), Some(&4));

pub fn cursor_idx_tsil_mut(&mut self, idx: usize) -> CursorMut<'_, T>

Returns mutable cursor to the element with LinkedList order.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_back(4);

*tc.cursor_idx_tsil_mut(0).current_mut().unwrap() = 0;
*tc.cursor_idx_tsil_mut(1).current_mut().unwrap() = 0;
*tc.cursor_idx_tsil_mut(2).current_mut().unwrap() = 0;
*tc.cursor_idx_tsil_mut(3).current_mut().unwrap() = 1;
assert_eq!(tc.cursor_idx_tsil_mut(0).current(), Some(&0));
assert_eq!(tc.cursor_idx_tsil_mut(1).current(), Some(&0));
assert_eq!(tc.cursor_idx_tsil_mut(2).current(), Some(&0));
assert_eq!(tc.cursor_idx_tsil_mut(3).current(), Some(&1));

pub fn into_vec(self) -> Vec<T>

Transform TsilCev to Vec with LinkedList order.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_back(4);

assert_eq!(tc.into_vec(), vec![1, 2, 3, 4]);

pub fn make_linked_list_order(&mut self)

Places elements inside TsilCev in the order of LinkedList without using additional memory.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_back(4);

tc.make_linked_list_order();
assert_eq!(tc.iter_cev().copied().collect::<Vec<_>>(), vec![1, 2, 3, 4]);

pub fn sort_by(&mut self, mut cmp: impl FnMut(&T, &T) -> Ordering)

Sorts the slice with a comparator function like in Vec. This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![5, 4, 1, 3, 2]);
tc.sort_by(|a, b| a.cmp(b));
assert_eq!(tc.to_vec(), &[1, 2, 3, 4, 5]);

// reverse sorting
tc.sort_by(|a, b| b.cmp(a));
assert_eq!(tc.to_vec(), &[5, 4, 3, 2, 1]);

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

Sorts the slice with a key extraction function like in Vec. This sort is stable (i.e., does not reorder equal elements) and O(m * n * log(n)) worst-case, where the key function is O(m).

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![-5i32, 4, 1, -3, 2]);

tc.sort_by_key(|k| k.abs());
assert_eq!(tc.to_vec(), &[1, 2, -3, 4, -5]);

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

Sorts the slice with a key extraction function like in Vec. During sorting, the key function is called only once per element.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![-5i32, 4, 32, -3, 2]);

tc.sort_by_cached_key(|k| k.to_string());
assert_eq!(tc.to_vec(), &[-3, -5, 2, 32, 4]);

pub fn sort_unstable_by(&mut self, mut cmp: impl FnMut(&T, &T) -> Ordering)

Sorts the slice with a comparator function, but may not preserve the order of equal elements like in Vec. This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(n * log(n)) worst-case.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![5, 4, 1, 3, 2]);
tc.sort_unstable_by(|a, b| a.cmp(b));
assert_eq!(tc.to_vec(), &[1, 2, 3, 4, 5]);

// reverse sorting
tc.sort_unstable_by(|a, b| b.cmp(a));
assert_eq!(tc.to_vec(), &[5, 4, 3, 2, 1]);

pub fn sort_unstable_by_key<K: Ord>(&mut self, mut f: impl FnMut(&T) -> K)

Sorts the slice with a key extraction function, but may not preserve the order of equal elements like in Vec. This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(m * n * log(n)) worst-case, where the key function is O(m).

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![-5i32, 4, 1, -3, 2]);

tc.sort_unstable_by_key(|k| k.abs());
assert_eq!(tc.to_vec(), &[1, 2, -3, 4, -5]);

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

Reserves capacity for at least additional more elements to be inserted like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

assert_eq!(tc.len(), 5);
assert!(tc.capacity() >= 5);

tc.reserve(10);
assert_eq!(tc.len(), 5);
assert!(tc.capacity() >= 15);

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

Reserves the minimum capacity for exactly additional more elements to be inserted in the given TsilCev like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

assert_eq!(tc.len(), 5);
assert!(tc.capacity() >= 5);

tc.reserve_exact(10);
assert_eq!(tc.len(), 5);
assert!(tc.capacity() >= 15);

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the TsilCev as much as possible like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

assert!(tc.capacity() >= 5);

tc.shrink_to_fit();
assert_eq!(tc.capacity(), 5);

pub fn capacity(&self) -> usize

Returns the number of elements the TsilCev can hold without reallocating like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

assert!(tc.capacity() >= 5);

pub fn len(&self) -> usize

Returns the number of elements in the TsilCev like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
assert_eq!(tc.capacity(), 5);

pub fn is_empty(&self) -> bool

Returns true if the TsilCev contains no elements like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
assert_eq!(tc.is_empty(), false);

tc.clear();
assert_eq!(tc.is_empty(), true);

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

Appends an element to the back (end) of a TsilCev like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

tc.push_back(5);
assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4, 5]);

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

Removes the last element from a TsilCev and returns it, or None if it is empty like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

tc.pop_back();
assert_eq!(tc.into_vec(), &[0, 1, 2, 3]);

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

Appends an element to the front (start) of a TsilCev like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

tc.push_front(5);
assert_eq!(tc.into_vec(), &[5, 0, 1, 2, 3, 4]);

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

Removes the first element from a TsilCev and returns it, or None if it is empty like in Vec.

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

tc.pop_front();
assert_eq!(tc.into_vec(), &[1, 2, 3, 4]);

impl<T: Clone> TsilCev<T>

pub fn to_vec(&self) -> Vec<T>

Copies TsilCev into a new Vec with LinkedList order.

use tsil_cev::TsilCev;

let mut tc = TsilCev::new();
tc.push_front(3);
tc.push_front(2);
tc.push_front(1);
tc.push_back(4);

assert_eq!(tc.to_vec(), vec![1, 2, 3, 4]);

Trait Implementations

impl<T: Clone> Clone for TsilCev<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TsilCev<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for TsilCev<T>

fn default() -> TsilCev<T>

Returns the "default value" for a type.

impl<T: Eq> Eq for TsilCev<T>

impl<'t, T: 't + Copy> Extend<&'t T> for TsilCev<T>

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

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

pub 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> Extend<T> for TsilCev<T>

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

use tsil_cev::TsilCev;

let mut tc = TsilCev::from(vec![0, 1, 2, 3, 4]);
tc.extend((5..=10).into_iter());

assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

let mut tc = TsilCev::new();
tc.extend((0..=4).into_iter());

assert_eq!(tc.into_vec(), TsilCev::from(vec![0, 1, 2, 3, 4]).into_vec());

pub fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

pub 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: Clone> From<&'_ [T]> for TsilCev<T>

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

use tsil_cev::TsilCev;

let tc = TsilCev::from(vec![0, 1, 2, 3, 4].as_slice());

assert_eq!(tc.front(), Some(&0));
assert_eq!(tc.back(), Some(&4));
assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4]);

impl<T: Clone> From<&'_ Vec<T, Global>> for TsilCev<T>

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

use tsil_cev::TsilCev;

let tc = TsilCev::from(&vec![0, 1, 2, 3, 4]);

assert_eq!(tc.front(), Some(&0));
assert_eq!(tc.back(), Some(&4));
assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4]);

impl<T> From<Vec<T, Global>> for TsilCev<T>

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

use tsil_cev::TsilCev;

let tc = TsilCev::from(vec![0, 1, 2, 3, 4]);

assert_eq!(tc.front(), Some(&0));
assert_eq!(tc.back(), Some(&4));
assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4]);

impl<T> FromIterator<T> for TsilCev<T>

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

use tsil_cev::TsilCev;

let tc = (0..=4).into_iter().map(|x| x).collect::<TsilCev<_>>();

assert_eq!(tc.into_vec(), &[0, 1, 2, 3, 4]);

impl<T: Hash> Hash for TsilCev<T>

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

Feeds this value into the given Hasher.

pub 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 TsilCev<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = TsilIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> TsilIntoIter<T>

Creates an iterator from a value.

impl<'t, T> IntoIterator for &'t TsilCev<T>

type Item = &'t T

The type of the elements being iterated over.

type IntoIter = TsilIter<'t, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> TsilIter<'t, T>

Creates an iterator from a value.

impl<'t, T> IntoIterator for &'t mut TsilCev<T>

type Item = &'t mut T

The type of the elements being iterated over.

type IntoIter = TsilIterMut<'t, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> TsilIterMut<'t, T>

Creates an iterator from a value.

impl<T: Ord> Ord for TsilCev<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<TsilCev<T>> for TsilCev<T>

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

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

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

This method tests for !=.

impl<T: PartialOrd> PartialOrd<TsilCev<T>> for TsilCev<T>

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

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

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

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

#[must_use]pub 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]pub fn gt(&self, other: &Rhs) -> bool

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

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

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