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>

pub fn inner(&self) -> &T

pub fn into_inner(self) -> T

impl<T> SplinterRef<T>

where T: AsRef<[u8]>,

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

pub fn size(&self) -> usize

Returns the size of this SplinterRef’s serialized bytes

Trait Implementations

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

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

Returns a duplicate of the value.

const 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<T1: AsRef<[u8]>, T2: AsRef<[u8]>> Cut<SplinterRef<T2>> for CowSplinter<T1>

type Output = Splinter

fn cut(&mut self, rhs: &SplinterRef<T2>) -> 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 From<CowSplinter<Bytes>> for SplinterRef<Bytes>

fn from(cow: CowSplinter<Bytes>) -> Self

Converts to this type from the input type.

impl<B> From<SplinterRef<B>> for CowSplinter<B>

fn from(splinter_ref: SplinterRef<B>) -> Self

Converts to this type from the input type.

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 CowSplinter<T1>

type Output = Splinter

fn intersection(&self, rhs: &SplinterRef<T2>) -> 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<T1: AsRef<[u8]>, T2: AsRef<[u8]>> Merge<SplinterRef<T2>> for CowSplinter<T1>

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

Merges rhs into self

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

fn eq(&self, other: &CowSplinter<T2>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<Splinter> for SplinterRef<T>

fn eq(&self, other: &Splinter) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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 ==.

const 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 CowSplinter<T1>

fn eq(&self, other: &SplinterRef<T2>) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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 ==.

const 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]>> SplinterRead for SplinterRef<T>

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());

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));

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());

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<_>>());

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

where R: RangeBounds<u32> + 'a,

Returns an sorted Iterator over all keys contained by the provided range.

Examples

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

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

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

Returns the last key 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!(Some(6), splinter.last());

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: AsRef<[u8]>, T2: AsRef<[u8]>> Union<SplinterRef<T2>> for CowSplinter<T1>

type Output = Splinter

fn union(&self, rhs: &SplinterRef<T2>) -> 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

impl<T1: AsRef<[u8]>> Eq for SplinterRef<T1>