Struct BitVecCore

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

A Core implementation that is conceptually a BitVec and a Vec<T>.

This is the default core as it has quite a few advantages. For one, it does not waste memory due to padding. The information about whether a slot is filled or not is stored in a BitVec and thus only takes one bit per slot.

Using a BitVec has another important advantage: iterating over the indices of a stable vector (i.e. without touching the actual data) is very cache-friendly. This is due to the dense packing of information. It’s also possible to very quickly scan the bit vector in order to find filled/empty slots.

However, this core implementation has disadvantages, too. It manages two allocations which means that reallocating (growing or shrinking) has to perform two allocations with the underlying memory allocator. Potentially more important is the decrease of cache-friendliness when accessing elements at random. Because in the worst case, this means that each element access results in two cache-misses instead of only one.

For most use cases, this is a good choice. That’s why it’s default.

Trait Implementations

impl<T: Clone> Clone for BitVecCore<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Core<T> for BitVecCore<T>

fn new() -> Self

Creates an empty instance without any elements. Must not allocate memory.

fn len(&self) -> usize

Returns the length of this core (the len). See the trait docs for more information.

unsafe fn set_len(&mut self, new_len: usize)

Sets the len to a new value.

fn cap(&self) -> usize

Returns the capacity of this core (the cap). See the trait docs for more information.

unsafe fn realloc(&mut self, new_cap: usize)

Reallocates the memory to have a cap of at least new_cap. This method should try its best to allocate exactly new_cap.

unsafe fn has_element_at(&self, idx: usize) -> bool

Checks if there exists an element with index idx.

unsafe fn insert_at(&mut self, idx: usize, elem: T)

Inserts elem at the index idx. Does not updated the used_len.

unsafe fn remove_at(&mut self, idx: usize) -> T

Removes the element at index idx and returns it.

unsafe fn get_unchecked(&self, idx: usize) -> &T

Returns a reference to the element at the index idx.

unsafe fn get_unchecked_mut(&mut self, idx: usize) -> &mut T

Returns a mutable reference to the element at the index idx.

fn clear(&mut self)

Deletes all elements without deallocating memory. Drops all existing elements. Sets len to 0.

unsafe fn swap(&mut self, a: usize, b: usize)

Swaps the two slots with indices a and b. That is: the element and the “filled/empty” status are swapped. The slots at indices a and b can be empty or filled.

unsafe fn first_filled_slot_from(&self, idx: usize) -> Option<usize>

Performs a forwards search starting at index idx, returning the index of the first filled slot that is found.

unsafe fn first_filled_slot_below(&self, idx: usize) -> Option<usize>

Performs a backwards search starting at index idx - 1, returning the index of the first filled slot that is found.

unsafe fn first_empty_slot_from(&self, idx: usize) -> Option<usize>

Performs a forwards search starting at index idx, returning the index of the first empty slot that is found.

unsafe fn first_empty_slot_below(&self, idx: usize) -> Option<usize>

Performs a backwards search starting at index idx - 1, returning the index of the first empty slot that is found.

impl<T> Debug for BitVecCore<T>

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

Formats the value using the given formatter.

impl<T> Drop for BitVecCore<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Send> Send for BitVecCore<T>

impl<T: Sync> Sync for BitVecCore<T>