issues-1223 Add InputSkip trait

src/bytes/complete.rs

@@ -6,7 +6,7 @@ use crate::internal::{Err, IResult, Parser};
 use crate::lib::std::ops::RangeFrom;
 use crate::lib::std::result::Result::*;
 use crate::traits::{
- Compare, CompareResult, FindSubstring, FindToken, InputIter, InputLength, InputTake,
+ Compare, CompareResult, FindSubstring, FindToken, InputIter, InputLength, InputSkip, InputTake,
  InputTakeAtPosition, Slice, ToUsize,
 };
 
@@ -414,6 +414,37 @@ where
  }
 }
 
+/// Skip a slice of N input elements (Input[N..]).
+///
+/// It will return `Err(Err::Error((_, ErrorKind::Eof)))` if the input is shorter than the argument.
+/// # Example
+/// ```rust
+/// # use nom::{Err, error::{Error, ErrorKind}, Needed, IResult};
+/// use nom::bytes::complete::skip;
+///
+/// fn skip6(s: &str) -> IResult<&str, ()> {
+/// skip(6usize)(s)
+/// }
+///
+/// assert_eq!(skip6("1234567"), Ok(("7", ())));
+/// assert_eq!(skip6("things"), Ok(("", ())));
+/// assert_eq!(skip6("short"), Err(Err::Error(Error::new("short", ErrorKind::Eof))));
+/// assert_eq!(skip6(""), Err(Err::Error(Error::new("", ErrorKind::Eof))));
+/// ```
+pub fn skip<C, Input, Error: ParseError<Input>>(
+ count: C,
+) -> impl Fn(Input) -> IResult<Input, (), Error>
+where
+ Input: InputIter + InputSkip,
+ C: ToUsize,
+{
+ let c = count.to_usize();
+ move |i: Input| match i.slice_index(c) {
+ Err(_needed) => Err(Err::Error(Error::from_error_kind(i, ErrorKind::Eof))),
+ Ok(index) => Ok((i.skip(index), ())),
+ }
+}
+
 /// Returns the input slice up to the first occurrence of the pattern.
 ///
 /// It doesn't consume the pattern. It will return `Err(Err::Error((_, ErrorKind::TakeUntil)))`

src/character/complete.rs

@@ -414,23 +414,23 @@ where
 /// assert_eq!(parser("c1"), Err(Err::Error(Error::new("c1", ErrorKind::Digit))));
 /// assert_eq!(parser(""), Err(Err::Error(Error::new("", ErrorKind::Digit))));
 /// ```
-/// 
+///
 /// ## Parsing an integer
 /// You can use `digit1` in combination with [`map_res`] to parse an integer:
-/// 
+///
 /// ```
 /// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};
 /// # use nom::combinator::map_res;
 /// # use nom::character::complete::digit1;
 /// fn parser(input: &str) -> IResult<&str, u32> {
 /// map_res(digit1, str::parse)(input)
 /// }
-/// 
+///
 /// assert_eq!(parser("416"), Ok(("", 416)));
 /// assert_eq!(parser("12b"), Ok(("b", 12)));
 /// assert!(parser("b").is_err());
 /// ```
-/// 
+///
 /// [`map_res`]: crate::combinator::map_res
 pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
 where

src/sequence/tests.rs

@@ -1,6 +1,6 @@
 use super::*;
 use crate::bytes::streaming::{tag, take};
-use crate::error::{ErrorKind, Error};
+use crate::error::{Error, ErrorKind};
 use crate::internal::{Err, IResult, Needed};
 use crate::number::streaming::be_u16;
 
@@ -275,7 +275,16 @@ fn tuple_test() {
 
 #[test]
 fn unit_type() {
- assert_eq!(tuple::<&'static str, (), Error<&'static str>, ()>(())("abxsbsh"), Ok(("abxsbsh", ())));
- assert_eq!(tuple::<&'static str, (), Error<&'static str>, ()>(())("sdfjakdsas"), Ok(("sdfjakdsas", ())));
- assert_eq!(tuple::<&'static str, (), Error<&'static str>, ()>(())(""), Ok(("", ())));
+ assert_eq!(
+ tuple::<&'static str, (), Error<&'static str>, ()>(())("abxsbsh"),
+ Ok(("abxsbsh", ()))
+ );
+ assert_eq!(
+ tuple::<&'static str, (), Error<&'static str>, ()>(())("sdfjakdsas"),
+ Ok(("sdfjakdsas", ()))
+ );
+ assert_eq!(
+ tuple::<&'static str, (), Error<&'static str>, ()>(())(""),
+ Ok(("", ()))
+ );
 }

src/traits.rs

@@ -332,6 +332,12 @@ pub trait InputTake: Sized {
  fn take_split(&self, count: usize) -> (Self, Self);
 }
 
+/// Abstracts skipping operation
+pub trait InputSkip: Sized {
+ /// Skip a slice of `count` bytes. panics if count > length
+ fn skip(&self, count: usize) -> Self;
+}
+
 impl<'a> InputIter for &'a [u8] {
  type Item = u8;
  type Iter = Enumerate<Self::IterElem>;
@@ -427,6 +433,20 @@ impl<'a> InputTake for &'a str {
  }
 }
 
+impl<'a> InputSkip for &'a [u8] {
+ #[inline]
+ fn skip(&self, count: usize) -> Self {
+ &self[count..]
+ }
+}
+
+impl<'a> InputSkip for &'a str {
+ #[inline]
+ fn skip(&self, count: usize) -> Self {
+ &self[count..]
+ }
+}
+
 /// Dummy trait used for default implementations (currently only used for `InputTakeAtPosition` and `Compare`).
 ///
 /// When implementing a custom input type, it is possible to use directly the