3 use self::Needed::*;
27   /// - "complete" parsers: It will not be an issue, `Incomplete` is never used
28   /// - "streaming" parsers: `Incomplete` will be returned if there's not enough data
32   fn finish(self) -> Result<(I, O), E>;  in finish()
36   fn finish(self) -> Result<(I, O), E> {  in finish()
47 /// Contains information on needed data if a parser returned `Incomplete`
50 pub enum Needed {  enum
57 impl Needed {  impl
58   /// Creates `Needed` instance, returns `Needed::Unknown` if the argument is zero
59   pub fn new(s: usize) -> Self {  in new()
61       Some(sz) => Needed::Size(sz),  in new()
62       None => Needed::Unknown,  in new()
67   pub fn is_known(&self) -> bool {  in is_known()
71   /// Maps a `Needed` to `Needed` by applying a function to a contained `Size` value.
73   pub fn map<F: Fn(NonZeroUsize) -> usize>(self, f: F) -> Needed {  in map()  argument
76       Size(n) => Needed::new(f(n)),  in map()
85 /// * `Incomplete` indicates that more data is needed to decide. The `Needed` enum
99   Incomplete(Needed),
110   pub fn is_incomplete(&self) -> bool {  in is_incomplete()
119   pub fn map<E2, F>(self, f: F) -> Err<E2>  in map()
121     F: FnOnce(E) -> E2,  in map()
131   pub fn convert<F>(e: Err<F>) -> Self  in convert()
140   /// Maps `Err<(T, ErrorKind)>` to `Err<(U, ErrorKind)>` with the given `F: T -> U`
141   pub fn map_input<U, F>(self, f: F) -> Err<(U, ErrorKind)>  in map_input()
143     F: FnOnce(T) -> U,  in map_input()
154   /// Maps `Err<error::Error<T>>` to `Err<error::Error<U>>` with the given `F: T -> U`
155   pub fn map_input<U, F>(self, f: F) -> Err<error::Error<U>>  in map_input()
157     F: FnOnce(T) -> U,  in map_input()
179   pub fn to_owned(self) -> Err<(Vec<u8>, ErrorKind)> {  in to_owned()
188   pub fn to_owned(self) -> Err<(String, ErrorKind)> {  in to_owned()
197   pub fn to_owned(self) -> Err<error::Error<Vec<u8>>> {  in to_owned()
206   pub fn to_owned(self) -> Err<error::Error<String>> {  in to_owned()
217   fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {  in fmt()
219       Err::Incomplete(Needed::Size(u)) => write!(f, "Parsing requires {} bytes/chars", u),  in fmt()
220       Err::Incomplete(Needed::Unknown) => write!(f, "Parsing requires more data"),  in fmt()
235   fn source(&self) -> Option<&(dyn Error + 'static)> {  in source()
244   fn parse(&mut self, input: I) -> IResult<I, O, E>;  in parse()
247   fn map<G, O2>(self, g: G) -> Map<Self, G, O>  in map()
249     G: Fn(O) -> O2,  in map()
260   fn flat_map<G, H, O2>(self, g: G) -> FlatMap<Self, G, O>  in flat_map()
262     G: FnMut(O) -> H,  in flat_map()
274   fn and_then<G, O2>(self, g: G) -> AndThen<Self, G, O>  in and_then()
287   fn and<G, O2>(self, g: G) -> And<Self, G>  in and()
296   fn or<G>(self, g: G) -> Or<Self, G>  in or()
306   fn into<O2: From<O>, E2: From<E>>(self) -> Into<Self, O, O2, E, E2>  in into()
322   F: FnMut(I) -> IResult<I, O, E> + 'a,
324   fn parse(&mut self, i: I) -> IResult<I, O, E> {  in parse()
334   fn parse(&mut self, input: I) -> IResult<I, O, E> {  in parse()
347 impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> O2> Parser<I, O2, E> for Map<F, G, O1> {
348   fn parse(&mut self, i: I) -> IResult<I, O2, E> {  in parse()
364 impl<'a, I, O1, O2, E, F: Parser<I, O1, E>, G: Fn(O1) -> H, H: Parser<I, O2, E>> Parser<I, O2, E>
367   fn parse(&mut self, i: I) -> IResult<I, O2, E> {  in parse()
384   fn parse(&mut self, i: I) -> IResult<I, O2, E> {  in parse()
401   fn parse(&mut self, i: I) -> IResult<I, (O1, O2), E> {  in parse()
418   fn parse(&mut self, i: I) -> IResult<I, O, E> {  in parse()
449   fn parse(&mut self, i: I) -> IResult<I, O2, E2> {  in parse()
476 …//FIXME: since rust 1.65, this is now 32 bytes, likely thanks to https://github.com/rust-lang/rust…  in size_test()
479     assert_size!(Needed, 8);  in size_test()