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

// Copyright 2020 ChainSafe Systems
// SPDX-License-Identifier: Apache-2.0

//! Implements serializer and deserializer for BinProt variable length integer

use core::marker::PhantomData;
use num::FromPrimitive;
use std::io::Cursor;

use crate::{ReadBinProtExt, WriteBinProtExt};
use serde::de::{self, Deserializer, Visitor};
use serde::ser::Serializer;

/// Serializer for variable length integer
pub fn serialize<T, S>(n: &T, s: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
    T: Into<i64> + Copy,
{
    let mut bytes = Vec::<u8>::new();
    bytes.bin_write_integer(*n).unwrap();
    s.serialize_bytes(&bytes)
}

struct IntegerVisitor<T>(PhantomData<T>);

impl<T> IntegerVisitor<T> {
    pub fn new() -> Self {
        IntegerVisitor::<T>(PhantomData)
    }
}

impl<'de, T> Visitor<'de> for IntegerVisitor<T>
where
    T: FromPrimitive,
{
    type Value = T;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("A bin_prot encoded integer (1, 3, 5, or 9 bytes depending on size)")
    }

    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        let mut rdr = Cursor::new(value);
        rdr.bin_read_integer()
            .map_err(|err| de::Error::custom(format!("Failed to read valid integer: {err}")))
    }
}

/// Deserializer for variable length integer
pub fn deserialize<'de, D, T>(d: D) -> Result<T, D::Error>
where
    D: Deserializer<'de>,
    T: FromPrimitive,
{
    d.deserialize_bytes(IntegerVisitor::new())
}