cu29_value/
bdec.rs

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
use crate::Value;
use bincode::BorrowDecode;
use std::collections::BTreeMap;

use bincode::de::Decoder;
use bincode::de::{BorrowDecoder, Decode};
use bincode::error::DecodeError;
use cu29_clock::CuTime;

// TODO: Unharcode all those enum types values
impl Decode for Value {
    fn decode<D: Decoder>(decoder: &mut D) -> Result<Self, DecodeError> {
        match u8::decode(decoder)? {
            0 => Ok(Value::Bool(bool::decode(decoder)?)),
            1 => Ok(Value::U8(u8::decode(decoder)?)),
            2 => Ok(Value::U16(u16::decode(decoder)?)),
            3 => Ok(Value::U32(u32::decode(decoder)?)),
            4 => Ok(Value::U64(u64::decode(decoder)?)),
            5 => Ok(Value::I8(i8::decode(decoder)?)),
            6 => Ok(Value::I16(i16::decode(decoder)?)),
            7 => Ok(Value::I32(i32::decode(decoder)?)),
            8 => Ok(Value::I64(i64::decode(decoder)?)),
            9 => Ok(Value::F32(f32::decode(decoder)?)),
            10 => Ok(Value::F64(f64::decode(decoder)?)),
            11 => Ok(Value::Char(char::decode(decoder)?)),
            12 => Ok(Value::String(String::decode(decoder)?)),
            13 => Ok(Value::Unit),
            14 => Ok(Value::Option(Option::<Box<Value>>::decode(decoder)?)),
            15 => Ok(Value::Newtype(Box::<Value>::decode(decoder)?)),
            16 => Ok(Value::Seq(Vec::<Value>::decode(decoder)?)),
            17 => Ok(Value::Map(BTreeMap::<Value, Value>::decode(decoder)?)),
            18 => Ok(Value::Bytes(Vec::<u8>::decode(decoder)?)),
            32 => Ok(Value::CuTime(CuTime::decode(decoder)?)),
            r => {
                println!("Unknown Value variant: {}", r);
                Err(DecodeError::Other("Unknown Value variant"))
            }
        }
    }
}

impl<'de> BorrowDecode<'de> for Value {
    fn borrow_decode<D: BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, DecodeError> {
        match u8::borrow_decode(decoder)? {
            0 => Ok(Value::U8(u8::borrow_decode(decoder)?)),
            1 => Ok(Value::U16(u16::borrow_decode(decoder)?)),
            2 => Ok(Value::U32(u32::borrow_decode(decoder)?)),
            3 => Ok(Value::U64(u64::borrow_decode(decoder)?)),
            4 => Ok(Value::I8(i8::borrow_decode(decoder)?)),
            5 => Ok(Value::I16(i16::borrow_decode(decoder)?)),
            6 => Ok(Value::I32(i32::borrow_decode(decoder)?)),
            7 => Ok(Value::I64(i64::borrow_decode(decoder)?)),
            8 => Ok(Value::F32(f32::borrow_decode(decoder)?)),
            9 => Ok(Value::F64(f64::borrow_decode(decoder)?)),
            10 => Ok(Value::Bool(bool::borrow_decode(decoder)?)),
            11 => Ok(Value::Char(char::borrow_decode(decoder)?)),
            12 => Ok(Value::String(String::borrow_decode(decoder)?)),
            13 => Ok(Value::Bytes(Vec::<u8>::borrow_decode(decoder)?)),
            14 => Ok(Value::Unit),
            15 => Ok(Value::Seq(Vec::<Value>::borrow_decode(decoder)?)),
            16 => Ok(Value::Map(BTreeMap::<Value, Value>::borrow_decode(
                decoder,
            )?)),
            17 => Ok(Value::Option(Option::<Box<Value>>::borrow_decode(decoder)?)),
            18 => Ok(Value::Newtype(Box::<Value>::borrow_decode(decoder)?)),
            _ => Err(DecodeError::Other("Unknown Value variant")),
        }
    }
}