splinter-rs 0.12.2

A compressed bitmap format optimized for small, sparse sets of u32s with zero-copy querying.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use std::iter::FusedIterator;

use num::traits::AsPrimitive;
use u24::u24;

pub type Segment = u8;

pub trait SplitSegment {
    type Rest;

    /// returns the first byte (segment) of `Self`
    fn segment(self) -> Segment;

    /// returns the remaining bytes
    fn rest(self) -> Self::Rest;

    /// splits the first byte (segment) off of `Self`
    fn split(self) -> (Segment, Self::Rest);

    /// performs the inverse of `Self::split`
    fn unsplit(segment: Segment, rest: Self::Rest) -> Self;

    /// returns the first value in the current segment
    /// equivalent to masking all of the trailing bytes to 0
    fn segment_start(self) -> Self;

    /// returns the last value in the current segment
    /// equivalent to masking all of the trailing bytes to 1
    fn segment_end(self) -> Self;
}

macro_rules! impl_split {
    ($(($ty:ty, $rest:ty, $segment_mask:expr)),*) => {
        $(
            impl SplitSegment for $ty {
                type Rest = $rest;

                #[inline(always)]
                fn segment(self) -> Segment {
                    (self >> (<$rest>::BITS as usize)).as_()
                }

                #[inline(always)]
                fn rest(self) -> Self::Rest {
                    self.as_()
                }

                #[inline(always)]
                fn split(self) -> (Segment, Self::Rest) {
                    (self.segment(), self.rest())
                }

                #[inline(always)]
                fn unsplit(segment: Segment, rest: Self::Rest) -> Self {
                    let segment: $ty = segment.as_();
                    let rest: $ty = rest.as_();
                    segment << (<$rest>::BITS as usize) | rest
                }

                #[inline(always)]
                fn segment_start(self) -> Self {
                    self & $segment_mask
                }

                #[inline(always)]
                fn segment_end(self) -> Self {
                    let rest_max: $ty = <$rest>::MAX.as_();
                    self | rest_max
                }
            }
        )*
    };
}

impl_split!(
    (u32, u24, 0xFF000000),
    (u24, u16, u24!(0xFF0000)),
    (u16, u8, 0xFF00)
);

impl SplitSegment for u8 {
    type Rest = u8;

    fn segment(self) -> Segment {
        self
    }
    fn rest(self) -> Self::Rest {
        unreachable!("BUG: can't split a u8")
    }
    fn split(self) -> (Segment, Self::Rest) {
        unreachable!("BUG: can't split a u8")
    }
    fn unsplit(_segment: Segment, _rest: Self::Rest) -> Self {
        unreachable!("BUG: can't unsplit a u8")
    }
    fn segment_start(self) -> Self {
        self
    }
    fn segment_end(self) -> Self {
        self
    }
}

/// An iterator of values that can be segmented into `(Segment, Rest)` pairs via
/// the `SplitSegment` trait.
#[must_use]
pub struct IterSegmented<I> {
    inner: I,
}

impl<I> IterSegmented<I> {
    pub fn new(inner: I) -> Self {
        Self { inner }
    }
}

impl<T: SplitSegment, I: Iterator<Item = T>> Iterator for IterSegmented<I> {
    type Item = (Segment, T::Rest);

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next().map(|v| v.split())
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.inner.size_hint()
    }
}

impl<T: SplitSegment, I: DoubleEndedIterator<Item = T>> DoubleEndedIterator for IterSegmented<I> {
    fn next_back(&mut self) -> Option<Self::Item> {
        self.inner.next_back().map(|v| v.split())
    }
}

impl<T: SplitSegment, I: FusedIterator<Item = T>> FusedIterator for IterSegmented<I> {}
impl<T: SplitSegment, I: ExactSizeIterator<Item = T>> ExactSizeIterator for IterSegmented<I> {}