Struct High 

pub struct High;

High is an internal type which is only exposed in docs due to it’s usage in the PartitionRead trait.

Trait Implementations

impl Clone for High

fn clone(&self) -> High

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for High

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

Formats the value using the given formatter.

impl Default for High

fn default() -> High

Returns the “default value” for a type.

impl PartialEq for High

fn eq(&self, other: &High) -> 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<B: Deref<Target = [u8]>> PartitionRead<High> for CowSplinter<B>

fn cardinality(&self) -> usize

the total number of values accessible via this partition.

fn is_empty(&self) -> bool

returns true if this partition is empty

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

returns true if this partition contains the given value

fn position(&self, value: u32) -> Option<usize>

returns the 0-based position of the value in the partition if it exists, otherwise returns None.

fn rank(&self, value: u32) -> usize

returns the number of values contained in this partition up to and including the value.

fn select(&self, idx: usize) -> Option<u32>

returns the value at position idx.

fn last(&self) -> Option<u32>

returns the last value in the partition

fn iter(&self) -> impl Iterator<Item = u32>

returns an iterator over all values in this partition

fn contains_all<R: RangeBounds<u32>>(&self, values: R) -> bool

returns true if this partition contains all values in the given range

fn contains_any<R: RangeBounds<u32>>(&self, values: R) -> bool

returns true if this partition has a non-empty intersection with the given range

fn range<R>(&self, range: R) -> impl Iterator<Item = L::Value>

where R: RangeBounds<L::Value> + Clone,

returns an iterator over all values in this partition restricted by the provided range.

impl PartitionRead<High> for Splinter

fn cardinality(&self) -> usize

Returns the total number of elements in this splinter.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let mut splinter = Splinter::EMPTY;
assert_eq!(splinter.cardinality(), 0);

let splinter = Splinter::from_iter([100, 200, 300]);
assert_eq!(splinter.cardinality(), 3);

fn is_empty(&self) -> bool

Returns true if this splinter contains no elements.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let mut splinter = Splinter::EMPTY;
assert!(splinter.is_empty());

let splinter = Splinter::from_iter([42]);
assert!(!splinter.is_empty());

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

Returns true if this splinter contains the specified value.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let splinter = Splinter::from_iter([42, 1337]);

assert!(splinter.contains(42));
assert!(splinter.contains(1337));
assert!(!splinter.contains(999));

fn position(&self, value: u32) -> Option<usize>

Returns the 0-based position of the value in this splinter if it exists.

This method searches for the given value in the splinter and returns its position in the sorted sequence of all elements. If the value doesn’t exist, returns None.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let splinter = Splinter::from_iter([10, 20, 30]);

assert_eq!(splinter.position(10), Some(0));
assert_eq!(splinter.position(20), Some(1));
assert_eq!(splinter.position(30), Some(2));
assert_eq!(splinter.position(25), None); // doesn't exist

fn rank(&self, value: u32) -> usize

Returns the number of elements in this splinter that are less than or equal to the given value.

This is also known as the “rank” of the value in the sorted sequence of all elements.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let splinter = Splinter::from_iter([10, 20, 30]);

assert_eq!(splinter.rank(5), 0);   // No elements <= 5
assert_eq!(splinter.rank(10), 1);  // One element <= 10
assert_eq!(splinter.rank(25), 2);  // Two elements <= 25
assert_eq!(splinter.rank(30), 3);  // Three elements <= 30
assert_eq!(splinter.rank(50), 3);  // Three elements <= 50

fn select(&self, idx: usize) -> Option<u32>

Returns the element at the given index in the sorted sequence, or None if the index is out of bounds.

The index is 0-based, so select(0) returns the smallest element.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let splinter = Splinter::from_iter([100, 50, 200]);

assert_eq!(splinter.select(0), Some(50));   // Smallest element
assert_eq!(splinter.select(1), Some(100));  // Second smallest
assert_eq!(splinter.select(2), Some(200));  // Largest element
assert_eq!(splinter.select(3), None);       // Out of bounds

fn last(&self) -> Option<u32>

Returns the largest element in this splinter, or None if it’s empty.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let mut splinter = Splinter::EMPTY;
assert_eq!(splinter.last(), None);

let splinter = Splinter::from_iter([100, 50, 200]);

assert_eq!(splinter.last(), Some(200));

fn iter(&self) -> impl Iterator<Item = u32>

Returns an iterator over all elements in ascending order.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let splinter = Splinter::from_iter([300, 100, 200]);

let values: Vec<u32> = splinter.iter().collect();
assert_eq!(values, vec![100, 200, 300]);

fn contains_all<R: RangeBounds<u32>>(&self, values: R) -> bool

Returns true if this splinter contains all values in the specified range.

This method checks whether every value within the given range bounds is present in the splinter. An empty range is trivially contained and returns true.

Examples

use splinter_rs::{Splinter, PartitionRead};

let splinter = Splinter::from_iter([10, 11, 12, 13, 14, 15, 100]);

// Check if range is fully contained
assert!(splinter.contains_all(10..=15));
assert!(splinter.contains_all(11..=14));

// Missing values mean the range is not fully contained
assert!(!splinter.contains_all(10..=16));  // 16 is missing
assert!(!splinter.contains_all(9..=15));   // 9 is missing

// Empty ranges are trivially contained
assert!(splinter.contains_all(50..50));

fn contains_any<R: RangeBounds<u32>>(&self, values: R) -> bool

Returns true if this splinter has a non-empty intersection with the specified range.

This method checks whether any value within the given range is present in the splinter. Returns false for empty ranges.

Examples

use splinter_rs::{Splinter, PartitionRead};

let splinter = Splinter::from_iter([10, 20, 30]);

// Check for any overlap
assert!(splinter.contains_any(10..=15));   // Contains 10
assert!(splinter.contains_any(5..=10));    // Contains 10
assert!(splinter.contains_any(25..=35));   // Contains 30

// No overlap
assert!(!splinter.contains_any(0..=9));    // No values in range
assert!(!splinter.contains_any(40..=50));  // No values in range

// Empty ranges have no intersection
assert!(!splinter.contains_any(50..50));

fn range<R>(&self, range: R) -> impl Iterator<Item = L::Value>

where R: RangeBounds<L::Value> + Clone,

returns an iterator over all values in this partition restricted by the provided range.

impl<B: Deref<Target = [u8]>> PartitionRead<High> for SplinterRef<B>

fn cardinality(&self) -> usize

the total number of values accessible via this partition.

fn is_empty(&self) -> bool

returns true if this partition is empty

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

returns true if this partition contains the given value

fn position(&self, value: u32) -> Option<usize>

returns the 0-based position of the value in the partition if it exists, otherwise returns None.

fn rank(&self, value: u32) -> usize

returns the number of values contained in this partition up to and including the value.

fn select(&self, idx: usize) -> Option<u32>

returns the value at position idx.

fn last(&self) -> Option<u32>

returns the last value in the partition

fn iter(&self) -> impl Iterator<Item = u32>

returns an iterator over all values in this partition

fn contains_all<R: RangeBounds<u32>>(&self, values: R) -> bool

returns true if this partition contains all values in the given range

fn contains_any<R: RangeBounds<u32>>(&self, values: R) -> bool

returns true if this partition has a non-empty intersection with the given range

fn range<R>(&self, range: R) -> impl Iterator<Item = L::Value>

where R: RangeBounds<L::Value> + Clone,

returns an iterator over all values in this partition restricted by the provided range.

impl<B: Deref<Target = [u8]>> PartitionWrite<High> for CowSplinter<B>

fn insert(&mut self, value: u32) -> bool

Inserts the value into the partition unless it already exists. Returns true if the insertion occurred, false otherwise.

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

Removes the value from the partition if it exists. Returns true if the removal occurred, false otherwise.

fn remove_range<R: RangeBounds<u32>>(&mut self, values: R)

Removes a range of values from the partition.

impl PartitionWrite<High> for Splinter

fn insert(&mut self, value: u32) -> bool

Inserts a value into this splinter.

Returns true if the value was newly inserted, or false if it was already present.

Examples

use splinter_rs::{Splinter, PartitionWrite, PartitionRead};

let mut splinter = Splinter::EMPTY;

// First insertion returns true
assert!(splinter.insert(42));
assert_eq!(splinter.cardinality(), 1);

// Second insertion of same value returns false
assert!(!splinter.insert(42));
assert_eq!(splinter.cardinality(), 1);

// Different value returns true
assert!(splinter.insert(100));
assert_eq!(splinter.cardinality(), 2);

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

Removes a value from this splinter.

Returns true if the value was present and removed, or false if it was not present.

Examples

use splinter_rs::{Splinter, PartitionWrite, PartitionRead};

let mut splinter = Splinter::from_iter([42, 100]);
assert_eq!(splinter.cardinality(), 2);

// Remove existing value
assert!(splinter.remove(42));
assert_eq!(splinter.cardinality(), 1);
assert!(!splinter.contains(42));
assert!(splinter.contains(100));

// Remove non-existent value
assert!(!splinter.remove(999));
assert_eq!(splinter.cardinality(), 1);

fn remove_range<R: RangeBounds<u32>>(&mut self, values: R)

Removes a range of values from this splinter.

This method removes all values that fall within the specified range bounds. The range can be inclusive, exclusive, or half-bounded using standard Rust range syntax.

Examples

use splinter_rs::{Splinter, PartitionRead, PartitionWrite};

let mut splinter = Splinter::from_iter(1..=10);

// Remove values 3 through 7 (inclusive)
splinter.remove_range(3..=7);
assert!(!splinter.contains(5));
assert!(splinter.contains(2));
assert!(splinter.contains(8));

// Remove from 9 onwards
splinter.remove_range(9..);
assert!(!splinter.contains(9));
assert!(!splinter.contains(10));
assert!(splinter.contains(8));

impl Copy for High

impl Eq for High

impl StructuralPartialEq for High