Struct orx_split_vec::CustomGrowth

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

Stategy which allows to define a custom growth rate with a function of priorly created fragments.

Examples

use orx_split_vec::SplitVec;

let mut vec = SplitVec::with_linear_growth(16);

for i in 0..10 * 16 {
    vec.push(i);
}

assert_eq!(10, vec.fragments().len());
for fragment in vec.fragments() {
    assert_eq!(16, fragment.len());
    assert_eq!(16, fragment.capacity());
}

vec.push(42);
assert_eq!(11, vec.fragments().len());
assert_eq!(Some(16), vec.fragments().last().map(|f| f.capacity()));
assert_eq!(Some(1), vec.fragments().last().map(|f| f.len()));

Implementations

impl<T> CustomGrowth<T>

pub fn new( get_capacity_of_new_fragment: Rc<dyn Fn(&[Fragment<T>]) -> usize> ) -> Self

Creates a new custom growth where the growth strategy is defined by the function get_capacity_of_new_fragment.

Panics

Panics if the function returns 0 as the capacity of the new fragment for any given set of already created fragments.

Trait Implementations

impl<T: Clone> Clone for CustomGrowth<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for CustomGrowth<T>

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

Formats the value using the given formatter.

impl<T: 'static> Default for CustomGrowth<T>

fn default() -> Self

Creates the default custom growth which doubles the initial capacity every 4 fragments.

Let c be the initial capacity of the split vector; i.e., capacity of the first fragment. Then, fragment capacities with the default function will be computed as:

• capacities of fragments 0..4 = c
• capacities of fragments 4..8 = 2c
• capacities of fragments 8..12 = 3c
• …

impl<T> SplitVecGrowth<T> for CustomGrowth<T>

fn new_fragment_capacity(&self, fragments: &[Fragment<T>]) -> usize

Given that the split vector contains the given fragments, returns the capacity of the next fragment.

fn get_fragment_and_inner_indices( &self, fragments: &[Fragment<T>], element_index: usize ) -> Option<(usize, usize)>

Returns the location of the element with the given element_index on the split vector as a tuple of (fragment-index, index-within-fragment).