oxidef_compact1 0.1.0-alpha.1

Oxidef is an experimental interface definition language and serialisation scheme for efficient and strongly-typed payloads.
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

use core::cmp::min;
use std::collections::HashMap;
use std::hash::Hash;

use crate::codec::Compact1CodecOpinion;
use crate::decoder::{DecError, Decoder, MeasureBuf};
use crate::encoder::{EncError, Encoder, ImprovidentBufMut};

/// Opinion on how to represent a `map` as a `HashMap`
pub struct HashMapOpinion<KO, VO> {
    /// Maximum number of items.
    /// Required as a safety feature to not allocate more memory than allowed.
    max_len: u32,
    /// Opinion for representing keys
    inner_k: KO,
    /// Opinion for representing values
    inner_v: VO,
}

impl<KO, VO> HashMapOpinion<KO, VO> {
    pub fn new(max_len: u32, inner_k: KO, inner_v: VO) -> Self {
        Self {
            inner_k,
            inner_v,
            max_len,
        }
    }
}

impl<K: Eq + Hash, KO: Compact1CodecOpinion<K>, V, VO: Compact1CodecOpinion<V>>
    Compact1CodecOpinion<HashMap<K, V>> for HashMapOpinion<KO, VO>
{
    fn encode<B: ImprovidentBufMut>(
        &self,
        encoder: &mut Encoder<B>,
        what: &HashMap<K, V>,
    ) -> Result<(), EncError>
    where
        Self: Sized,
    {
        let items = what.len();
        if items > min(self.max_len, crate::vu29::VU29_MAX_4BYTE) as usize {
            return Err(EncError::ContainerTooLong);
        }
        crate::vu29::encode_vu29(encoder.buf.deref_mut(), items as u32)?;

        for (key, value) in what {
            self.inner_k.encode(encoder, key)?;
            self.inner_v.encode(encoder, value)?;
        }

        Ok(())
    }

    fn decode<B: MeasureBuf>(&self, decoder: &mut Decoder<B>) -> Result<HashMap<K, V>, DecError> {
        let num_items = crate::vu29::decode_vu29(&mut decoder.buf)?;

        if num_items > self.max_len {
            return Err(DecError::ContainerTooLong);
        }

        let mut out = HashMap::with_capacity(num_items as usize);

        for _ in 0..num_items {
            let k = self.inner_k.decode(decoder)?;
            let v = self.inner_v.decode(decoder)?;
            if out.insert(k, v).is_some() {
                return Err(DecError::DuplicateMapKeys);
            }
        }

        Ok(out)
    }
}