Struct bcder::decode::LimitedSource

pub struct LimitedSource<S> { /* fields omitted */ }

A source that can be limited to a certain number of octets.

This type wraps another source and allows access to be limited to a certain number of octets. It will never provide access to more than that number of octets. Any attempt to advance over more octets will fail with a malformed error.

The limit is, however, independent of the underlying source. It can be larger than the number of octets actually available in the source.

The limit can be changed or even removed at any time.

Implementations

impl<S> LimitedSource<S>

General Management

pub fn new(source: S) -> Self

Creates a new limited source for the given source.

The return limited source will have no limit just yet.

pub fn unwrap(self) -> S

Unwraps the value and returns the source it was created from.

pub fn limit(&self) -> Option<usize>

Returns the current limit.

Returns None if there is no limit. Otherwise, the number returned is the number of remaining octets before the limit is reached. This does not necessarily mean that that many octets are actually available in the underlying source.

pub fn limit_further(&mut self, limit: Option<usize>) -> Option<usize>

Sets a more strict limit.

The method will panic (!) if you are trying to set a new limit that is larger than the current limit or if you are trying to remove the limit by passing None if there currently is a limit set.

Returns the old limit.

pub fn set_limit(&mut self, limit: Option<usize>)

Unconditionally sets a new limit.

If you pass None, the limit will be removed.

impl<S: Source> LimitedSource<S>

Advanced Access

pub fn skip_all(&mut self) -> Result<(), S::Err>

Skip over all remaining octets until the current limit is reached.

If there currently is no limit, the method will panic. Otherwise it will simply advance to the end of the limit which may be something the underlying source doesn’t like and thus produce an error.

pub fn take_all(&mut self) -> Result<Bytes, S::Err>

Returns a bytes value containing all octets until the current limit.

If there currently is no limit, the method will panic. Otherwise it tries to acquire a bytes value for the octets from the current position to the end of the limit and advance to the end of the limit. This may result in an error by the underlying source.

pub fn exhausted(&mut self) -> Result<(), S::Err>

Checks whether the end of the limit has been reached.

If a limit is currently set, the method will return a malformed error if it is larger than zero, i.e., if there are octets left to advance over before reaching the limit.

If there is no limit set, the method will try to access one single octet and return a malformed error if that is actually possible, i.e., if there are octets left in the underlying source.

Trait Implementations

impl<S: Clone> Clone for LimitedSource<S>

pub fn clone(&self) -> LimitedSource<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug> Debug for LimitedSource<S>

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

Formats the value using the given formatter.

impl<S: Source> Source for LimitedSource<S>

type Err = S::Err

The error produced by the source.

pub fn request(&mut self, len: usize) -> Result<usize, Self::Err>

Request at least len bytes to be available.

pub fn advance(&mut self, len: usize) -> Result<(), Self::Err>

Advance the source by len bytes.

pub fn slice(&self) -> &[u8]

Returns a bytes slice with the available data.

pub fn bytes(&self, start: usize, end: usize) -> Bytes

Produces a Bytes value from part of the data.

pub fn take_u8(&mut self) -> Result<u8, Self::Err>

Takes a single octet from the source.

pub fn take_opt_u8(&mut self) -> Result<Option<u8>, Self::Err>

Takes an optional octet from the source.