Struct ExpLinkedList 

pub struct ExpLinkedList<T> { /* private fields */ }

A linked list that grows exponentially. It is used to store a large number of elements in a memory-efficient way. The list grows by doubling the capacity of the last element when it’s full, the capacity can be limited by the limit parameter. The default value is 0, which means no limit.

Implementations

impl<T> ExpLinkedList<T>

pub fn new() -> Self

Creates a new empty ExpLinkedList.

pub fn with_capacity(capacity: usize) -> Self

pub fn with_capacity_limit(self, limit: u16) -> Self

Creates a new ExpLinkedList with a specified capacity limit. The limit is the maximum capacity of a single node in the list. If the limit is 0, there is no limit.

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

Pushes a new element into the list. If the last element in the list reaches its capacity, a new node is created with double capacity.

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

Removes the last element from the list.

pub fn clear(&mut self)

Clears the list, removing all elements. This will free the memory used by the list.

pub fn len(&self) -> usize

Returns the number of elements in the list.

pub fn is_empty(&self) -> bool

Returns whether the list is empty.

pub fn size(&self) -> usize

Returns the size of list, including the size of the elements and the size of the list itself, and the unused space. The element size is calculated using std::mem::size_of::<T>(), so it is not accurate for all types. For example, for String, it will return the size of the pointer, not the size of the string itself. For that you need to use DeepSizeOf.

pub fn iter(&self) -> ExpLinkedListIter<'_, T>

Returns an iterator over the elements in the list.

pub fn block_iter(&self) -> impl Iterator<Item = &[T]>

Trait Implementations

impl<T: Clone> Clone for ExpLinkedList<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ExpLinkedList<T>

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

Formats the value using the given formatter.

impl<T: DeepSizeOf> DeepSizeOf for ExpLinkedList<T>

fn deep_size_of_children(&self, context: &mut Context) -> usize

Returns an estimation of the heap-managed storage of this object. This does not include the size of the object itself.

fn deep_size_of(&self) -> usize

Returns an estimation of a total size of memory owned by the object, including heap-managed storage.

impl<T: Default> Default for ExpLinkedList<T>

fn default() -> ExpLinkedList<T>

Returns the “default value” for a type.

impl<T> FromIterator<T> for ExpLinkedList<T>

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

Creates a value from an iterator.

impl<T> IntoIterator for ExpLinkedList<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = ExpLinkedListIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for ExpLinkedList<T>

where T: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Eq for ExpLinkedList<T>

where T: Eq,