ic-platform-protocol 0.3.4

Bounded external protocol formats for IC Platform
Documentation
use super::Error;

pub(crate) enum FieldValue<'a> {
    Integer(u64),
    Bytes(&'a [u8]),
    Fixed,
}

pub(crate) trait Read: Sized {
    fn read(value: FieldValue<'_>, remaining: &mut usize) -> Result<Self, Error>;
}

impl Read for u64 {
    fn read(value: FieldValue<'_>, _: &mut usize) -> Result<Self, Error> {
        match value {
            FieldValue::Integer(value) => Ok(value),
            _ => Err(Error::Malformed),
        }
    }
}
impl Read for bool {
    fn read(value: FieldValue<'_>, remaining: &mut usize) -> Result<Self, Error> {
        match u64::read(value, remaining)? {
            0 => Ok(false),
            1 => Ok(true),
            _ => Err(Error::Malformed),
        }
    }
}
impl<T: Read> Read for Option<T> {
    fn read(value: FieldValue<'_>, remaining: &mut usize) -> Result<Self, Error> {
        T::read(value, remaining).map(Some)
    }
}

pub(crate) struct Reader<'a> {
    rest: &'a [u8],
}

impl<'a> Reader<'a> {
    pub(crate) fn new(bytes: &'a [u8]) -> Self {
        Self { rest: bytes }
    }

    fn take(&mut self, count: usize) -> Result<&'a [u8], Error> {
        let (head, tail) = self.rest.split_at_checked(count).ok_or(Error::Malformed)?;
        self.rest = tail;
        Ok(head)
    }

    fn integer(&mut self) -> Result<u64, Error> {
        let mut value = 0u64;
        for shift in (0..70).step_by(7) {
            let byte = self.take(1)?[0];
            if shift == 63 && byte > 1 {
                return Err(Error::Malformed);
            }
            value |= u64::from(byte & 127) << shift;
            if byte & 128 == 0 {
                return Ok(value);
            }
        }
        Err(Error::Malformed)
    }

    pub(crate) fn next(
        &mut self,
        remaining: &mut usize,
    ) -> Result<Option<(u32, FieldValue<'a>)>, Error> {
        if self.rest.is_empty() {
            return Ok(None);
        }
        *remaining = remaining.checked_sub(1).ok_or(Error::FieldLimit)?;
        let key = self.integer()?;
        let number = key >> 3;
        if number == 0 || number > 0x1fff_ffff {
            return Err(Error::Malformed);
        }
        let value = match key & 7 {
            0 => FieldValue::Integer(self.integer()?),
            1 => {
                self.take(8)?;
                FieldValue::Fixed
            }
            2 => {
                let count = usize::try_from(self.integer()?).map_err(|_| Error::Malformed)?;
                FieldValue::Bytes(self.take(count)?)
            }
            5 => {
                self.take(4)?;
                FieldValue::Fixed
            }
            _ => return Err(Error::UnsupportedWireType),
        };
        Ok(Some((number as u32, value)))
    }
}