binary-cookies 0.3.1

BinaryCookies decode and encode
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

use oval::Buffer;
use winnow::{
    stream::{Offset, Stream},
    Parser,
};

use super::{meta::MetaOffset, pages::PagesOffset, DecodeResult};
use crate::{cookie::BinaryCookies, decode::StreamIn, error::Result};

#[derive(Clone)]
#[derive(Debug)]
#[derive(PartialEq)]
pub struct BinaryCookieFsm {
    pub(crate) buffer: Buffer,
}

impl Default for BinaryCookieFsm {
    fn default() -> Self {
        Self::new()
    }
}

// binary cookies metadata
#[derive(Clone)]
#[derive(Debug)]
#[derive(Default)]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub struct Offsets {
    pub(crate) page_sizes: Vec<u32>, // be
    pub(crate) tail_offset: u64,
}

impl BinaryCookieFsm {
    /// 4(`magic`) + 4(`num_pages`) + 4 * `num_pages`
    /// assume `num_pages` = 2 round up to a power of 2
    const BUF_SIZE: usize = 4 + 4 + 4 * 2;

    pub fn new() -> Self {
        Self {
            buffer: Buffer::with_capacity(Self::BUF_SIZE),
        }
    }

    pub fn process(mut self) -> Result<DecodeResult<Self, (MetaOffset, PagesOffset, Buffer)>> {
        let mut input: StreamIn = StreamIn::new(self.buffer.data());
        let start = input.checkpoint();

        let e = match BinaryCookies::decode_head.parse_next(&mut input) {
            Ok(offsets) => {
                let consumed = input.offset_from(&start);
                self.buffer.consume(consumed);
                return Ok(DecodeResult::Done((
                    offsets.tail_offset,
                    PagesOffset::new(offsets.page_sizes),
                    self.buffer,
                )));
            },
            Err(e) => e,
        };
        mode_err! {self, e, self.buffer}
    }
}