Struct Dynamic 

pub struct Dynamic<T: Indexable + Ord>
where
    T::Key: Ord,
{ /* private fields */ }

A dynamic PGM-Index that supports insertions and deletions.

This index owns its data and maintains insert/delete buffers that are periodically merged into the main index. When the buffers exceed a threshold, the index is automatically rebuilt.

Example

use pgm_extra::index::owned::Dynamic;

let mut index: Dynamic<u64> = Dynamic::new(16, 4);

index.insert(5);
index.insert(3);
index.insert(7);

assert!(index.contains(&3));
assert!(index.contains(&5));
assert!(!index.contains(&4));

Implementations

impl<T: Indexable + Ord + Copy> Dynamic<T>

where T::Key: Ord,

pub fn new(epsilon: usize, epsilon_recursive: usize) -> Self

Create a new empty dynamic index.

pub fn from_sorted( data: Vec<T>, epsilon: usize, epsilon_recursive: usize, ) -> Result<Self, Error>

Create a dynamic index from pre-sorted data.

pub fn with_rebuild_threshold(self, threshold: usize) -> Self

Set the threshold for automatic rebuilding.

pub fn insert(&mut self, value: T)

Insert a value into the index.

pub fn remove(&mut self, value: &T) -> bool

Remove a value from the index.

pub fn contains(&self, value: &T) -> bool

Check if a value exists in the index.

pub fn lower_bound(&self, value: &T) -> Option<T>

Find the smallest value >= the given value.

pub fn len(&self) -> usize

Get the number of elements in the index.

pub fn is_empty(&self) -> bool

pub fn pending_operations(&self) -> usize

Get the number of pending operations in buffers.

pub fn force_rebuild(&mut self)

Force an immediate rebuild of the index.

pub fn iter(&self) -> impl Iterator<Item = T> + '_

Iterate over all values in sorted order.

pub fn range<'a, R>(&'a self, range: R) -> impl Iterator<Item = T> + 'a

where R: RangeBounds<T> + Clone + 'a,

Iterate over values in the given range.

pub fn size_in_bytes(&self) -> usize

Approximate memory usage in bytes.

Trait Implementations

impl<T: Indexable + Ord + Debug> Debug for Dynamic<T>

where T::Key: Ord,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Dynamic<T>

where T::Key: Ord + Serialize + DeserializeOwned, T: Serialize + DeserializeOwned + Indexable + Ord,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Indexable + Ord + Copy> Extend<T> for Dynamic<T>

where T::Key: Ord,

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

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<T> Serialize for Dynamic<T>

where T::Key: Ord + Serialize + DeserializeOwned, T: Serialize + DeserializeOwned + Indexable + Ord,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.