automerge/columnar/column_range/generic/
simple.rs

1use std::ops::Range;
2
3use crate::columnar::{
4    column_range::{BooleanRange, DeltaRange, RleRange},
5    encoding::{raw, BooleanDecoder, DeltaDecoder, RleDecoder},
6};
7
8use super::SimpleValue;
9
10/// The four types of "simple" column defined in the raw format
11#[derive(Debug, Clone)]
12pub(crate) enum SimpleColRange {
13    /// A column containing RLE encoded u64's
14    RleInt(RleRange<u64>),
15    /// A column containing RLE encoded strings
16    RleString(RleRange<smol_str::SmolStr>),
17    /// A column containing delta -> RLE encoded i64s
18    Delta(DeltaRange),
19    /// A column containing boolean values
20    Boolean(BooleanRange),
21}
22
23impl SimpleColRange {
24    pub(super) fn iter<'a>(&self, data: &'a [u8]) -> SimpleColIter<'a> {
25        match self {
26            Self::RleInt(r) => SimpleColIter::RleInt(r.decoder(data)),
27            Self::RleString(r) => SimpleColIter::RleString(r.decoder(data)),
28            Self::Delta(r) => SimpleColIter::Delta(r.decoder(data)),
29            Self::Boolean(r) => SimpleColIter::Boolean(r.decoder(data)),
30        }
31    }
32
33    pub(crate) fn range(&self) -> Range<usize> {
34        match self {
35            Self::RleInt(r) => r.clone().into(),
36            Self::RleString(r) => r.clone().into(),
37            Self::Delta(r) => r.clone().into(),
38            Self::Boolean(r) => r.clone().into(),
39        }
40    }
41}
42
43#[derive(Debug, Clone)]
44pub(crate) enum SimpleColIter<'a> {
45    RleInt(RleDecoder<'a, u64>),
46    RleString(RleDecoder<'a, smol_str::SmolStr>),
47    Delta(DeltaDecoder<'a>),
48    Boolean(BooleanDecoder<'a>),
49}
50
51impl SimpleColIter<'_> {
52    fn try_next(&mut self) -> Result<Option<SimpleValue>, raw::Error> {
53        match self {
54            Self::RleInt(d) => read_col(d, SimpleValue::Uint),
55            Self::RleString(d) => read_col(d, SimpleValue::String),
56            Self::Delta(d) => read_col(d, SimpleValue::Int),
57            Self::Boolean(d) => Ok(d.next().transpose()?.map(SimpleValue::Bool)),
58        }
59    }
60}
61
62fn read_col<C, T, F, U>(mut col: C, f: F) -> Result<Option<U>, raw::Error>
63where
64    C: Iterator<Item = Result<Option<T>, raw::Error>>,
65    F: Fn(Option<T>) -> U,
66{
67    col.next().transpose().map(|v| v.map(f))
68}
69
70impl Iterator for SimpleColIter<'_> {
71    type Item = Result<SimpleValue, raw::Error>;
72
73    fn next(&mut self) -> Option<Self::Item> {
74        self.try_next().transpose()
75    }
76}