Struct Limit 

pub struct Limit<R> { /* private fields */ }

Limit the number of bytes that can be read out of a reader to the specified limit.

This type wraps another reader and ensures that no more than a specified number of bytes can be read from it. This is useful for implementing bounded reads in serialization contexts.

Constructed through Reader::limit.

Examples

use musli::Context;
use musli::reader::{Reader, SliceReader};

let cx = musli::context::new();
let data = &[1, 2, 3, 4, 5];
let mut reader = SliceReader::new(data);
let mut limited = reader.limit(3);

// Can read from the limited reader
let byte = limited.read_byte(&cx)?;
assert_eq!(byte, 1);
assert_eq!(limited.remaining(), 2);

// Read two more bytes
limited.read_byte(&cx)?;
limited.read_byte(&cx)?;
assert_eq!(limited.remaining(), 0);

Implementations

impl<R> Limit<R>

pub fn remaining(&self) -> usize

Get the remaining data in the limited reader.

Returns the number of bytes that can still be read from this limited reader before the limit is reached.

Examples

use musli::reader::{Reader, SliceReader};

let data = &[1, 2, 3, 4, 5];
let mut reader = SliceReader::new(data);
let limited = reader.limit(3);

assert_eq!(limited.remaining(), 3);

Trait Implementations

impl<'de, R> Reader<'de> for Limit<R>

where R: Reader<'de>,

type Mut<'this> = &'this mut Limit<R> where Self: 'this

Type borrowed from self.

type TryClone = Limit<<R as Reader<'de>>::TryClone>

Type that can be cloned from the reader.

fn borrow_mut(&mut self) -> Self::Mut<'_>

Borrow the current reader.

fn try_clone(&self) -> Option<Self::TryClone>

Try to clone the reader.

fn is_eof(&mut self) -> bool

Test if the reader is at end of input.

fn skip<C>(&mut self, cx: C, n: usize) -> Result<(), C::Error>

where C: Context,

Skip over the given number of bytes.

fn read_bytes<C, V>( &mut self, cx: C, n: usize, visitor: V, ) -> Result<V::Ok, V::Error>

where C: Context, V: UnsizedVisitor<'de, C, [u8], Error = C::Error, Allocator = C::Allocator>,

Read a slice out of the current reader.

unsafe fn read_bytes_uninit<C>( &mut self, cx: C, ptr: *mut u8, n: usize, ) -> Result<(), C::Error>

where C: Context,

Read into the given buffer which might not have been initialized.

fn peek(&mut self) -> Option<u8>

Peek the next value.

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

where C: Context,

Read a slice into the given buffer.

fn read_byte<C>(&mut self, cx: C) -> Result<u8, C::Error>

where C: Context,

Read a single byte.

fn read_array<C, const N: usize>(&mut self, cx: C) -> Result<[u8; N], C::Error>

where C: Context,

Read an array out of the current reader.

fn limit(self, limit: usize) -> Limit<Self>

where Self: Sized,

Keep an accurate record of the position within the reader.