Struct nom8::input::Stateful

pub struct Stateful<I, S> {
    pub input: I,
    pub state: S,
}

Thread global state through your parsers

Use cases

• Recusion checks
• Errror recovery
• Debugging

Example

#[derive(Clone, Debug)]
struct State<'s>(&'s Cell<u32>);

impl<'s> State<'s> {
    fn count(&self) {
        self.0.set(self.0.get() + 1);
    }
}

type Input<'is> = Stateful<&'is str, State<'is>>;

fn word(i: Input<'_>) -> IResult<Input<'_>, &str> {
  i.state.count();
  alpha1(i)
}

let data = "Hello";
let state = Cell::new(0);
let input = Input { input: data, state: State(&state) };
let output = word.parse(input).finish().unwrap();
assert_eq!(state.get(), 1);

Fields

input: I

Inner input being wrapped in state

state: S

User-provided state

Trait Implementations

impl<I, S> AsBytes for Stateful<I, S>where
    I: AsBytes,

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

Casts the input type to a byte slice

impl<I, S> AsRef<I> for Stateful<I, S>

fn as_ref(&self) -> &I

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

impl<I: Clone, S: Clone> Clone for Stateful<I, S>

fn clone(&self) -> Stateful<I, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, S, U> Compare<U> for Stateful<I, S>where
    I: Compare<U>,

fn compare(&self, other: U) -> CompareResult

Compares self to another value for equality

fn compare_no_case(&self, other: U) -> CompareResult

Compares self to another value for equality independently of the case.

impl<I: Debug, S: Debug> Debug for Stateful<I, S>

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

Formats the value using the given formatter.

impl<I, S> Deref for Stateful<I, S>

type Target = I

The resulting type after dereferencing.

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

Dereferences the value.

impl<I, S> ExtendInto for Stateful<I, S>where
    I: ExtendInto,

type Item = <I as ExtendInto>::Item

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

type Extender = <I as ExtendInto>::Extender

The type that will be produced

fn new_builder(&self) -> Self::Extender

Create a new Extend of the correct type

fn extend_into(&self, extender: &mut Self::Extender)

Accumulate the input into an accumulator

impl<I, S, T> FindSubstring<T> for Stateful<I, S>where
    I: FindSubstring<T>,

fn find_substring(&self, substr: T) -> Option<usize>

Returns the byte position of the substring if it is found

impl<I, S> HexDisplay for Stateful<I, S>where
    I: HexDisplay,

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<I, S> InputIsStreaming<false> for Stateful<I, S>where
    I: InputIsStreaming<false>,

type Complete = Stateful<I, S>

Complete counterpart

type Streaming = Stateful<<I as InputIsStreaming<false>>::Streaming, S>

Streaming counterpart

fn into_complete(self) -> Self::Complete

Convert to complete counterpart

fn into_streaming(self) -> Self::Streaming

Convert to streaming counterpart

impl<I, S> InputIsStreaming<true> for Stateful<I, S>where
    I: InputIsStreaming<true>,

type Complete = Stateful<<I as InputIsStreaming<true>>::Complete, S>

Complete counterpart

type Streaming = Stateful<I, S>

Streaming counterpart

fn into_complete(self) -> Self::Complete

Convert to complete counterpart

fn into_streaming(self) -> Self::Streaming

Convert to streaming counterpart

impl<I, S> InputIter for Stateful<I, S>where
    I: InputIter,

type Item = <I as InputIter>::Item

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

type Iter = <I as InputIter>::Iter

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

type IterElem = <I as InputIter>::IterElem

An iterator over the input type, producing the item

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

Returns an iterator over the elements and their byte offsets

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

Returns an iterator over the elements

fn position<P>(&self, predicate: P) -> Option<usize>where
    P: Fn(Self::Item) -> bool,

Finds the byte position of the element

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

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

impl<I, S> InputLength for Stateful<I, S>where
    I: InputLength,

fn input_len(&self) -> usize

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

impl<I, S> InputTake for Stateful<I, S>where
    I: InputTake,
    S: Clone,

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

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

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

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

impl<I, S> InputTakeAtPosition for Stateful<I, S>where
    I: InputTakeAtPosition,
    S: Clone,

type Item = <I as InputTakeAtPosition>::Item

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

fn split_at_position_complete<P, E>(
    &self,
    predicate: P
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

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_streaming<P, E>(
    &self,
    predicate: P
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

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_streaming<P, E>(
    &self,
    predicate: P,
    kind: ErrorKind
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

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,
    kind: ErrorKind
) -> IResult<Self, Self, E>where
    P: Fn(Self::Item) -> bool,
    E: ParseError<Self>,

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

impl<I, S> IntoOutput for Stateful<I, S>where
    I: IntoOutput,

type Output = <I as IntoOutput>::Output

Output type

fn into_output(self) -> Self::Output

Convert an Input into an appropriate Output type

fn merge_output(self, inner: Self::Output) -> Self

Convert an Output type to be used as Input

impl<I, S> Location for Stateful<I, S>where
    I: Location,

fn location(&self) -> usize

Number of indices input has advanced since start of parsing

impl<I, S> Offset for Stateful<I, S>where
    I: Offset,

fn offset(&self, other: &Self) -> usize

Offset between the first byte of self and the first byte of the argument

impl<I, S, R> ParseTo<R> for Stateful<I, S>where
    I: ParseTo<R>,

fn parse_to(&self) -> Option<R>

Succeeds if parse() succeeded. The byte slice implementation will first convert it to a &str, then apply the parse() function

impl<I: PartialEq, S: PartialEq> PartialEq<Stateful<I, S>> for Stateful<I, S>

fn eq(&self, other: &Stateful<I, S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<I, S, R> Slice<R> for Stateful<I, S>where
    I: Slice<R>,
    S: Clone,

fn slice(&self, range: R) -> Self

Slices self according to the range argument

impl<I: Copy, S: Copy> Copy for Stateful<I, S>

impl<I: Eq, S: Eq> Eq for Stateful<I, S>

impl<I, S> StructuralEq for Stateful<I, S>

impl<I, S> StructuralPartialEq for Stateful<I, S>