Function decode_internal

avro/src/decode.rs:77–352

(
    schema: &Schema,
    names: &HashMap<Name, S>,
    enclosing_namespace: NamespaceRef,
    reader: &mut R,
)

/// shared budget of [`max_allocation_bytes`] bytes, instead of each
/// collection only being checked in isolation.
#[derive(Debug)]
pub(crate) struct DecodeContext {
    /// Bytes still available for allocations while decoding the current datum.
    remaining_budget: usize,
    /// Current recursion depth of `decode_internal`.
    depth: usize,
}

impl DecodeContext {
    /// Create a new context.
    ///
    /// This should only be done when a new datum is being decoded, never during the decoding.
    pub(crate) fn new() -> Self {
        Self {
            remaining_budget: max_allocation_bytes(DEFAULT_MAX_ALLOCATION_BYTES),
            depth: 0,
        }
    }

    /// Debit `bytes` from the per-datum allocation budget
    ///
    /// # Errors
    /// `Details::MemoryAllocation` if the maximum budget is exceeded.
    fn debit_bytes(&mut self, bytes: usize) -> AvroResult<()> {
        match self.remaining_budget.checked_sub(bytes) {
            Some(remaining) => {
                self.remaining_budget = remaining;
                Ok(())
            }
            None => Err(Details::MemoryAllocation {
                desired: Some(bytes),
                maximum: max_allocation_bytes(DEFAULT_MAX_ALLOCATION_BYTES),
            }
            .into()),
        }
    }

    /// Debit the amount of bytes for `n` items of `T`.
    ///
    /// # Errors
    /// `Details::MemoryAllocation` if the maximum budget is exceeded.
    fn debit_items<T>(&mut self, n: usize) -> AvroResult<()> {
        let bytes = n
            .checked_mul(size_of::<T>())
            .ok_or(Details::IntegerOverflow)?;
        self.debit_bytes(bytes)
    }

    /// Track one level of decoding recursion, erroring once the configured
    /// maximum depth is exceeded.
    fn enter(&mut self) -> AvroResult<()> {
        self.depth += 1;
        let maximum = decode_recursion_limit();
        if self.depth > maximum {
            Err(Details::DecodeRecursionLimit { maximum }.into())
        } else {
            Ok(())
        }