Struct Input 

pub struct Input<'a, Extra = ()> { /* private fields */ }

Implementations

impl<'a, Extra> Input<'a, Extra>

pub fn replace_extra<E>(self, extra: &'a E) -> Input<'a, E>

Trait Implementations

impl<'a, Extra> Deref for Input<'a, Extra>

type Target = ReflessInput<'a>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Extra> DerefMut for Input<'_, Extra>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Extra> ParseInput for Input<'_, Extra>

fn parse_chunk<'a, const N: usize>(&mut self) -> Result<&'a [u8; N]>

where Self: 'a,

fn parse_n<'a>(&mut self, n: usize) -> Result<&'a [u8]>

where Self: 'a,

fn parse_ahead<T: Parse<Self>>(&mut self, n: usize) -> Result<T>

fn parse_compare<T: ParseInline<Self>>( &mut self, n: usize, c: &[u8], ) -> Result<Option<T>>

fn parse_all<'a>(self) -> Result<&'a [u8]>

where Self: 'a,

fn empty(self) -> Result<()>

fn non_empty(self) -> Result<Option<Self>>

fn consume(self, f: impl FnMut(&mut Self) -> Result<()>) -> Result<()>

fn parse_collect<T: ParseInline<Self>, B: FromIterator<T>>(self) -> Result<B>

fn collect<T, B: FromIterator<T>>( self, f: impl FnMut(&mut Self) -> Result<T>, ) -> Result<B>

fn iter<T>( self, f: impl FnMut(&mut Self) -> Result<T>, ) -> impl Iterator<Item = Result<T>>

fn parse_inline<T: ParseInline<Self>>(&mut self) -> Result<T>

fn parse<T: Parse<Self>>(self) -> Result<T>

fn parse_vec<T: ParseInline<Self>>(self) -> Result<Vec<T>>

impl<'a, Extra: 'static + Clone> PointInput for Input<'a, Extra>

type Extra = Extra

type WithExtra<E: 'static + Clone> = Input<'a, E>

fn next_index(&mut self) -> usize

fn resolve_arc_ref(&self) -> &Arc<dyn Resolve>

fn extra(&self) -> &Self::Extra

fn map_extra<E: 'static + Clone>( self, f: impl FnOnce(&Self::Extra) -> &E, ) -> Self::WithExtra<E>

fn resolve(&self) -> Arc<dyn Resolve>

fn resolve_ref(&self) -> &dyn Resolve

fn extension<T: Any>(&self) -> Result<&T>