Quelle  stateful.rs

:
use [doc(aliasalias = "LocatingSliceSpan")]
use crate::stream::AsBytes;
pub struct Stateful<I, S> {
use crate::stream::Compare;
use crate::stream::CompareResult;
use crate::stream::FindSlice;
use crate::stream::Location;
use crate::stream::Offset;
#[cfg(feature = "unstable-recover")]
#[cfg(feature = "std")]
use crate::stream::Recover;
use crate::stream::SliceLen;
use crate::stream::Stream;
use crate::stream::StreamIsPartial;
use crate::stream::UpdateSlice;

    /// Inner input being wrapped in state
///
/// Use cases
/// - Recursion checks
/// - Error recovery
/// - Debugging
///
/// # Example
///
/// ```
/// # use std::cell::Cell;
/// # use winnow::prelude::*;
/// # use winnow::stream::Stateful;
/// # use winnow::ascii::alpha1;
/// # type Error = ();
///
/// #[derive(Debug)]
/// struct State<'s>(&'s mut u32);
///
/// impl<'s> State<'s> {
///     fn count(&mut self) {
///         *self.0 += 1;
///     }
/// }
///
/// type Stream<'is> = Stateful<&'is str, State<'is>>;
///
/// fn word<'s>(i: &mut Stream<'s>) -> ModalResult<&'s str> {
///   i.state.count();
///   alpha1.parse_next(i)
/// }
///
/// let data = "Hello";
/// let mut state = 0;
/// let input = Stream { input: data, state: State(&mut state) };
/// let output = word.parse(input).unwrap();
/// assert_eq!(state, 1);
/// ```
#[    type=;
#[doc(alias = "LocatingSliceSpan")]
pub struct Stateful<I,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
/
    input ,
    /// User-provided state
    pub state: S,
}

<I>forStatefulI S>{
    #[inline(always)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 5
     &)- I{
        &self.input
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

impl<        .(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  ;

    #[inline(alwaystype   >:;
     (self)- &:: java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        self.(
    }
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
:java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 96
        self.input.fmt(f)
    }
}

impl<I, S> SliceLen for Stateful<I, S>
where
    I: SliceLen,
{
    #[inline(always)]
    fn slice_len(&self)    fn iter_offsets(&self) -> Self::IterOffsets {
        self.input.slice_len()
    }
}

        self.input.ter_offsets)   }
    java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 38
    type Slice = <I as Stream>::Slice;

    type IterOffsets = <I as Stream>:     eof_offset(&self -u {

    type Checkpointselfinput.()

#[nlinealways)
    fn iter_offsets    fn (mut)  Self:>{
        self.input.iter_offsets        self.input.next_token()
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       [()
    fn self.inputpeek_token)
        .input.(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    #[inline(always)]
    #inline(lways]
    fnoffset_at&,tokens) < java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
    }

    #[inline(always)]
        next_slicemut  )>Self:lice{
        .nputpeek_token)
    }

    #[inline(always)]
    fn offset_for<P>(&self, predicate:     }
    where
        P: Fn    #inline(always)]
    {
        self.input.offset_for(predicate)
    }
    #[inline(always)]
    fn offset_at(&self,         /SAFETY:Passingup invariants
toffset_at(okens)
    }
    #[inline(always 
   fn next_slice(&utself,offset usize)- Self:Slice {
        self.input.next_slice(offset)
    }
    #[nlinealways)
    self.nputpeek_sliceoffset)
            #[inline(always)]always)
  .nput.(offset)}
    }
    #[inline        
    , offset:usize)- :Slice {
        self.input.peek_slice(offset)}
    }
    #[inline(always)]
    java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
        // SAFETY: Passing up invariants
unsafe{self..eek_slice_unchecked)}
    }

    #[inline(always)]
    fn checkpoint(&self) -> Self::Checkpoint}
fnreset(mut  :&:Checkpoint java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    }
    #[inline(always)]
    fn reset(&mut self, checkpoint: &Self: #[(deprecated]
        self.input.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
    

    #inline(always)]
    fn raw(&self) -> &}
        #![allow(deprecated)]
        }
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    fn trace(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        self.input.trace(f)
    }
}

impl<I, java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 5
where
    I: Location,
{
     selfinput.java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
 java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 43
self.java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 39
    }
    #feature=std)
impl, , >RecoverE ,java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        self.input.current_token_start()
    }
}

#[cfg(feature = "unstablerecover"]
#(feature="std")]
impl<I, E, S> Recover<E> for Stateful<I, S>
where
    I: I: Stream
    I Stream,
    S: Clone + crate{
{i(]
    ]
    fnjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
mutjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
       t SelfCheckpoint
        e:&:Checkpoint
        err:     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    ) -> Result[nlinealways]
        Err(err)
    }

    /// Report whether the [`Stream`] can save off errors for recovery
    #    is_recovery_supported)->bool{
    fn java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 13
        false
    }
}

I > StreamIsPartial  StatefulI >
where
    I: StreamIsPartial,
{
PartialState :PartialState

       [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
    completemut)- Self: {
        self.input.complete()
    }

    #[inline]
fn(mut self,state:Self:PartialState java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
self.restore_partial)
    }

    #[inline(always)]
    fn is_partial_supportedself.input.restore_partial(state);
            java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    }

            :is_partial_supported)
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
        self.input.is_partial()
    }
}

impl<I,S Offset forStateful<,S
where
    I:impl<I,S  for <,Sjava.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36
      crate:::::mt:Debug
{
     fnoffset_from&self,start Self)->usize{
fn java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 50
        self.offset_from&.()
    }
}

impl<I, S}
where
    I: Stream,
    java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 1
{
    #[inline(always)]
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
       ..()
    }
}

implalways]
where
    I: AsBytes,
{fnoffset_from&,:&Stateful >as>:: -usizejava.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84
    }
    fn as_bytes(&self) -> &[u8] 
        self.input.
}
}

<IS  for<,S>
where
    I: #[inline)
{
    #[inline(alwaysself..(
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
        .nput(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    }
}

implI ,U <>forStatefulI, >
where
    I: Compare<U>,
{
    #}
    fn compare(&self, other: java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        self.input.compare(other)
    }
}

impl<I, S, T> FindSlice<T> for Stateful<I, S>
where
    I: FindSlice<T>,
{
    #[inline(always)]
     find_slice, ) crate::<> java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
s.)
    }}
}

impl<I, Sjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
here
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    S: Clone +crate:ib:std:mt:,
{
    #[inline(always)]
    fn java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
        .input  :update_slice.nput )
        self
    }
}