Struct deku::error::NeedSize

pub struct NeedSize { /* private fields */ }

Number of bits needed to retry parsing

Implementations

impl NeedSize

pub fn new(bits: usize) -> Self

Create new NeedSize from bits

Examples found in repository

src/impls/primitive.rs (line 27)

    fn read(
        input: &BitSlice<u8, Msb0>,
        (_, size): (Endian, ByteSize),
    ) -> Result<(&BitSlice<u8, Msb0>, Self), DekuError> {
        const MAX_TYPE_BITS: usize = BitSize::of::<u8>().0;
        let bit_size: usize = size.0 * 8;

        // TODO
        // if they never give [bits] or [bytes] we don't need to check the size
        if bit_size > MAX_TYPE_BITS {
            return Err(DekuError::Parse(format!(
                "too much data: container of {} bits cannot hold {} bits",
                MAX_TYPE_BITS, bit_size
            )));
        }

        if input.len() < bit_size {
            return Err(DekuError::Incomplete(crate::error::NeedSize::new(bit_size)));
        }

        let (bit_slice, rest) = input.split_at(bit_size);
        let pad = 8 * ((bit_slice.len() + 7) / 8) - bit_slice.len();

        let value = if pad == 0
            && bit_slice.len() == MAX_TYPE_BITS
            && bit_slice.domain().region().unwrap().1.len() * 8 == MAX_TYPE_BITS
        {
            // if everything is aligned, just read the value
            bit_slice.load::<u8>()
        } else {
            let mut bits: BitVec<u8, Msb0> = BitVec::with_capacity(bit_slice.len() + pad);

            // Copy bits to new BitVec
            bits.extend_from_bitslice(bit_slice);

            // Force align
            //i.e. [1110, 10010110] -> [11101001, 0110]
            bits.force_align();

            let bytes: &[u8] = bits.as_raw_slice();

            // cannot use from_X_bytes as we don't have enough bytes for $typ
            // read manually
            let mut res: u8 = 0;
            for b in bytes.iter().rev() {
                res |= *b as u8;
            }

            res as u8
        };

        Ok((rest, value))
    }

pub fn bit_size(&self) -> usize

Number of bits needed

Examples found in repository

src/error.rs (line 72)

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        match *self {
            DekuError::Incomplete(ref size) => write!(
                f,
                "Not enough data, need {} bits (or {} bytes)",
                size.bit_size(),
                size.byte_size()
            ),
            DekuError::Parse(ref err) => write!(f, "Parse error: {}", err),
            DekuError::InvalidParam(ref err) => write!(f, "Invalid param error: {}", err),
            DekuError::Unexpected(ref err) => write!(f, "Unexpected error: {}", err),
            DekuError::Assertion(ref err) => write!(f, "Assertion error: {}", err),
            DekuError::IdVariantNotFound => write!(f, "Could not resolve `id` for variant"),
        }
    }

pub fn byte_size(&self) -> usize

Number of bytes needed

Examples found in repository

src/error.rs (line 73)

    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        match *self {
            DekuError::Incomplete(ref size) => write!(
                f,
                "Not enough data, need {} bits (or {} bytes)",
                size.bit_size(),
                size.byte_size()
            ),
            DekuError::Parse(ref err) => write!(f, "Parse error: {}", err),
            DekuError::InvalidParam(ref err) => write!(f, "Invalid param error: {}", err),
            DekuError::Unexpected(ref err) => write!(f, "Unexpected error: {}", err),
            DekuError::Assertion(ref err) => write!(f, "Assertion error: {}", err),
            DekuError::IdVariantNotFound => write!(f, "Could not resolve `id` for variant"),
        }
    }

Trait Implementations

impl Clone for NeedSize

fn clone(&self) -> NeedSize

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NeedSize

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<NeedSize> for NeedSize

fn eq(&self, other: &NeedSize) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for NeedSize

impl StructuralEq for NeedSize

impl StructuralPartialEq for NeedSize