Struct SplinterRef

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

A compressed bitmap for u32 keys operating directly on a slice of bytes

Implementations

impl<T> SplinterRef<T>

where T: AsRef<[u8]>,

pub fn from_bytes(data: T) -> Result<Self, Culprit<DecodeErr>>

pub fn size(&self) -> usize

pub fn inner(&self) -> &T

pub fn into_inner(self) -> T

pub fn is_empty(&self) -> bool

Returns true if the splinter is empty.

Examples

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

let mut splinter = Splinter::default();
splinter.insert(1);
let splinter = splinter.serialize_to_splinter_ref();
assert!(!splinter.is_empty());

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

Returns true if the splinter contains the given key.

Examples

let mut splinter = Splinter::default();
splinter.insert(1);
splinter.insert(3);
let splinter = splinter.serialize_to_splinter_ref();

assert!(splinter.contains(1));
assert!(!splinter.contains(2));
assert!(splinter.contains(3));

pub fn cardinality(&self) -> usize

Calculates the total number of values stored in the set.

Examples

let mut splinter = Splinter::default();
splinter.insert(6);
splinter.insert(1);
splinter.insert(3);
let splinter = splinter.serialize_to_splinter_ref();

assert_eq!(3, splinter.cardinality());

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

Returns an sorted Iterator over all keys.

Examples

let mut splinter = Splinter::default();
splinter.insert(6);
splinter.insert(1);
splinter.insert(3);
let splinter = splinter.serialize_to_splinter_ref();

assert_eq!(&[1, 3, 6], &*splinter.iter().collect::<Vec<_>>());

Trait Implementations

impl<T: Clone> Clone for SplinterRef<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: AsRef<[u8]>> Cut<SplinterRef<T>> for Splinter

type Output = Splinter

fn cut(&mut self, rhs: &SplinterRef<T>) -> Self::Output

Returns the intersection between self and other while removing the intersection from self

impl<T: AsRef<[u8]>> Debug for SplinterRef<T>

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

Formats the value using the given formatter.

impl<T: AsRef<[u8]>> From<SplinterRef<T>> for Splinter

fn from(value: SplinterRef<T>) -> Self

Converts to this type from the input type.

impl<T: AsRef<[u8]>> Intersection<Splinter> for SplinterRef<T>

type Output = Splinter

fn intersection(&self, rhs: &Splinter) -> Self::Output

Returns the intersection between self and other

impl<T: AsRef<[u8]>> Intersection<SplinterRef<T>> for Splinter

type Output = Splinter

fn intersection(&self, rhs: &SplinterRef<T>) -> Self::Output

Returns the intersection between self and other

impl<T1: AsRef<[u8]>, T2: AsRef<[u8]>> Intersection<SplinterRef<T2>> for SplinterRef<T1>

type Output = Splinter

fn intersection(&self, rhs: &SplinterRef<T2>) -> Self::Output

Returns the intersection between self and other

impl<T: AsRef<[u8]>> Merge<SplinterRef<T>> for Splinter

fn merge(&mut self, rhs: &SplinterRef<T>)

Merges rhs into self

impl<T: AsRef<[u8]>> PartialEq<Splinter> for SplinterRef<T>

fn eq(&self, other: &Splinter) -> 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: AsRef<[u8]>> PartialEq<SplinterRef<T>> for Splinter

fn eq(&self, other: &SplinterRef<T>) -> 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<T1: AsRef<[u8]>, T2: AsRef<[u8]>> PartialEq<SplinterRef<T2>> for SplinterRef<T1>

fn eq(&self, other: &SplinterRef<T2>) -> 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: AsRef<[u8]>> Union<Splinter> for SplinterRef<T>

type Output = Splinter

fn union(&self, rhs: &Splinter) -> Self::Output

Returns the union between self and other

impl<T: AsRef<[u8]>> Union<SplinterRef<T>> for Splinter

type Output = Splinter

fn union(&self, rhs: &SplinterRef<T>) -> Self::Output

Returns the union between self and other

impl<T1, T2> Union<SplinterRef<T2>> for SplinterRef<T1>

where T1: AsRef<[u8]>, T2: AsRef<[u8]>,

type Output = Splinter

fn union(&self, rhs: &SplinterRef<T2>) -> Self::Output

Returns the union between self and other