Struct Input

pub struct Input<'a> { /* private fields */ }

BER/DER parser input type

Implementations

impl<'a> Input<'a>

pub const fn new(data: &'a [u8], span: Range<usize>) -> Self

Build a new `Input``

pub const fn from_slice(data: &'a [u8]) -> Self

pub const fn const_clone(&self) -> Self

pub const fn span(&self) -> &Range<usize>

pub const fn start(&self) -> usize

pub const fn end(&self) -> usize

pub const fn len(&self) -> usize

pub const fn is_empty(&self) -> bool

pub const fn as_bytes2(&self) -> &'a [u8]

pub const fn into_bytes(self) -> &'a [u8]

Trait Implementations

impl<'a> AsBytes for Input<'a>

fn as_bytes(&self) -> &'a [u8]

Casts the input type to a byte slice

impl<'a> AsRef<[u8]> for Input<'a>

fn as_ref(&self) -> &'a [u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Input<'a>

fn clone(&self) -> Input<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Input<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Input<'a>

fn default() -> Input<'a>

Returns the “default value” for a type.

impl Display for Input<'_>

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

Formats the value using the given formatter.

impl<'a> From<&'a [u8]> for Input<'a>

fn from(data: &'a [u8]) -> Self

Converts to this type from the input type.

impl<'a, const N: usize> From<&'a [u8; N]> for Input<'a>

fn from(value: &'a [u8; N]) -> Self

Converts to this type from the input type.

impl<'a> From<&'a Vec<u8>> for Input<'a>

fn from(data: &'a Vec<u8>) -> Self

Converts to this type from the input type.

impl<'a> Hash for Input<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl HexDisplay for Input<'_>

fn to_hex(&self, chunk_size: usize) -> String

Converts the value of self to a hex dump, returning the owned String.

fn to_hex_from(&self, chunk_size: usize, from: usize) -> String

Converts the value of self to a hex dump beginning at from address, returning the owned String.

impl<'a> Input for Input<'a>

type Item = u8

The current input type is a sequence of that Item type.

type Iter = Cloned<Iter<'a, u8>>

An iterator over the input type, producing the item

type IterIndices = Enumerate<<Input<'a> as Input>::Iter>

An iterator over the input type, producing the item and its byte position If we’re iterating over &str, the position corresponds to the byte index of the character

fn input_len(&self) -> usize

Calculates the input length, as indicated by its name, and the name of the trait itself

fn take(&self, index: usize) -> Self

Returns a slice of index bytes. panics if index > length

fn take_from(&self, index: usize) -> Self

Returns a slice starting at index bytes. panics if index > length

fn take_split(&self, index: usize) -> (Self, Self)

Split the stream at the index byte offset. panics if index > length

fn position<P>(&self, predicate: P) -> Option<usize>

where P: Fn(Self::Item) -> bool,

Returns the byte position of the first element satisfying the predicate

fn iter_elements(&self) -> Self::Iter

Returns an iterator over the elements

fn iter_indices(&self) -> Self::IterIndices

Returns an iterator over the elements and their byte offsets

fn slice_index(&self, count: usize) -> Result<usize, Needed>

Get the byte offset from the element’s position in the stream

fn split_at_position<P, E>(&self, predicate: P) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1<P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position_complete<P, E>( &self, predicate: P, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true, and returns the input up to this position.

fn split_at_position1_complete<P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, Self), Err<E>>

where E: ParseError<Self>, P: Fn(Self::Item) -> bool,

Looks for the first element of the input type for which the condition returns true and returns the input up to this position.

fn split_at_position_mode<OM, P, E>( &self, predicate: P, ) -> Result<(Self, <<OM as OutputMode>::Output as Mode>::Output<Self>), Err<E, <<OM as OutputMode>::Error as Mode>::Output<E>>>

where OM: OutputMode, E: ParseError<Self>, P: Fn(Self::Item) -> bool,

mode version of split_at_position

fn split_at_position_mode1<OM, P, E>( &self, predicate: P, e: ErrorKind, ) -> Result<(Self, <<OM as OutputMode>::Output as Mode>::Output<Self>), Err<E, <<OM as OutputMode>::Error as Mode>::Output<E>>>

where OM: OutputMode, E: ParseError<Self>, P: Fn(Self::Item) -> bool,

mode version of split_at_position

impl<'a> PartialEq for Input<'a>

fn eq(&self, other: &Input<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a> Eq for Input<'a>

impl<'a> StructuralPartialEq for Input<'a>