Struct soroban_env_host::xdr::DepthLimitedRead

pub struct DepthLimitedRead<R>where
    R: Read,{
    pub inner: R,
    /* private fields */
}

DepthLimitedRead wraps a Read object and enforces a depth limit to recursive read operations. It maintains a depth_remaining state tracking remaining allowed recursion depth.

Fields

inner: R

Implementations

impl<R> DepthLimitedRead<R>where R: Read,

pub fn new(inner: R, depth_limit: u32) -> DepthLimitedRead<R>

Constructs a new DepthLimitedRead.

• inner: The object implementing the Read trait.
• depth_limit: The maximum allowed recursion depth.

Trait Implementations

impl<R> DepthLimiter for DepthLimitedRead<R>where R: Read,

fn enter(&mut self) -> Result<(), Error>

Decrements the depth_remaining. If the depth_remaining is already zero, an error is returned indicating that the maximum depth limit has been exceeded.

fn leave(&mut self) -> Result<(), Error>

Increments the depth. leave should be called in tandem with enter such that the depth doesn’t exceed the initial depth limit.

type DepthLimiterError = Error

A general error type for any type implementing, or an operation under the guard of DepthLimiter. It must at least include the error case where the depth limit is exceeded which is returned from enter.

fn with_limited_depth<T, F>( &mut self, f: F ) -> Result<T, Self::DepthLimiterError>where F: FnOnce(&mut Self) -> Result<T, Self::DepthLimiterError>,

Wraps a given function f with depth limiting guards. It triggers an enter before, and a leave after the execution of f.

impl<R> Read for DepthLimitedRead<R>where R: Read,

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Forwards the read operation to the wrapped object.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8, Global>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>where Self: Sized,

Creates an adapter which will read at most limit bytes from it.