//! Character specific parsers and combinators, streaming version

//!

//! Functions recognizing specific characters

use crate::branch::alt;

use crate::combinator::opt;

use crate::error::ErrorKind;

use crate::error::ParseError;

use crate::internal::{Err, IResult, Needed};

use crate::traits::{AsChar, FindToken, Input};

use crate::traits::{Compare, CompareResult};

use crate::Emit;

use crate::OutputM;

use crate::Parser;

use crate::Streaming;

/// Recognizes one character.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};

/// # use nom::character::streaming::char;

/// fn parser(i: &str) -> IResult<&str, char> {

///     char('a')(i)

/// }

/// assert_eq!(parser("abc"), Ok(("bc", 'a')));

/// assert_eq!(parser("bc"), Err(Err::Error(Error::new("bc", ErrorKind::Char))));

/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn char<I, Error: ParseError<I>>(c: char) -> impl FnMut(I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

{

  let mut parser = super::char(c);

  move |i: I| parser.process::<OutputM<Emit, Emit, Streaming>>(i)

}

/// Recognizes one character and checks that it satisfies a predicate

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::{ErrorKind, Error}, Needed, IResult};

/// # use nom::character::streaming::satisfy;

/// fn parser(i: &str) -> IResult<&str, char> {

///     satisfy(|c| c == 'a' || c == 'b')(i)

/// }

/// assert_eq!(parser("abc"), Ok(("bc", 'a')));

/// assert_eq!(parser("cd"), Err(Err::Error(Error::new("cd", ErrorKind::Satisfy))));

/// assert_eq!(parser(""), Err(Err::Incomplete(Needed::Unknown)));

/// ```

pub fn satisfy<F, I, Error: ParseError<I>>(cond: F) -> impl FnMut(I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

  F: Fn(char) -> bool,

{

  let mut parser = super::satisfy(cond);

  move |i: I| parser.process::<OutputM<Emit, Emit, Streaming>>(i)

}

/// Recognizes one of the provided characters.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, Needed};

/// # use nom::character::streaming::one_of;

/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("abc")("b"), Ok(("", 'b')));

/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("a")("bc"), Err(Err::Error(("bc", ErrorKind::OneOf))));

/// assert_eq!(one_of::<_, _, (_, ErrorKind)>("a")(""), Err(Err::Incomplete(Needed::Unknown)));

/// ```

pub fn one_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

  T: FindToken<char>,

{

  let mut parser = super::one_of(list);

  move |i: I| parser.process::<OutputM<Emit, Emit, Streaming>>(i)

}

/// Recognizes a character that is not in the provided characters.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, Needed};

/// # use nom::character::streaming::none_of;

/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("abc")("z"), Ok(("", 'z')));

/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("ab")("a"), Err(Err::Error(("a", ErrorKind::NoneOf))));

/// assert_eq!(none_of::<_, _, (_, ErrorKind)>("a")(""), Err(Err::Incomplete(Needed::Unknown)));

/// ```

pub fn none_of<I, T, Error: ParseError<I>>(list: T) -> impl FnMut(I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

  T: FindToken<char>,

{

  let mut parser = super::none_of(list);

  move |i: I| parser.process::<OutputM<Emit, Emit, Streaming>>(i)

}

/// Recognizes the string "\r\n".

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::crlf;

/// assert_eq!(crlf::<_, (_, ErrorKind)>("\r\nc"), Ok(("c", "\r\n")));

/// assert_eq!(crlf::<_, (_, ErrorKind)>("ab\r\nc"), Err(Err::Error(("ab\r\nc", ErrorKind::CrLf))));

/// assert_eq!(crlf::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(2))));

/// ```

pub fn crlf<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  T: Compare<&'static str>,

{

  match input.compare("\r\n") {

    //FIXME: is this the right index?

    CompareResult::Ok => Ok(input.take_split(2)),

    CompareResult::Incomplete => Err(Err::Incomplete(Needed::new(2))),

    CompareResult::Error => {

      let e: ErrorKind = ErrorKind::CrLf;

      Err(Err::Error(E::from_error_kind(input, e)))

    }

  }

}

/// Recognizes a string of any char except '\r\n' or '\n'.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::{Error, ErrorKind}, IResult, Needed};

/// # use nom::character::streaming::not_line_ending;

/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("ab\r\nc"), Ok(("\r\nc", "ab")));

/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("abc"), Err(Err::Incomplete(Needed::Unknown)));

/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::Unknown)));

/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("a\rb\nc"), Err(Err::Error(("a\rb\nc", ErrorKind::Tag ))));

/// assert_eq!(not_line_ending::<_, (_, ErrorKind)>("a\rbc"), Err(Err::Error(("a\rbc", ErrorKind::Tag ))));

/// ```

pub fn not_line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  T: Compare<&'static str>,

  <T as Input>::Item: AsChar,

{

  match input.position(|item| {

    let c = item.as_char();

    c == '\r' || c == '\n'

  }) {

    None => Err(Err::Incomplete(Needed::Unknown)),

    Some(index) => {

      let mut it = input.take_from(index).iter_elements();

      let nth = it.next().unwrap().as_char();

      if nth == '\r' {

        let sliced = input.take_from(index);

        let comp = sliced.compare("\r\n");

        match comp {

          //FIXME: calculate the right index

          CompareResult::Incomplete => Err(Err::Incomplete(Needed::Unknown)),

          CompareResult::Error => {

            let e: ErrorKind = ErrorKind::Tag;

            Err(Err::Error(E::from_error_kind(input, e)))

          }

          CompareResult::Ok => Ok(input.take_split(index)),

        }

      } else {

        Ok(input.take_split(index))

      }

    }

  }

}

/// Recognizes an end of line (both '\n' and '\r\n').

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::line_ending;

/// assert_eq!(line_ending::<_, (_, ErrorKind)>("\r\nc"), Ok(("c", "\r\n")));

/// assert_eq!(line_ending::<_, (_, ErrorKind)>("ab\r\nc"), Err(Err::Error(("ab\r\nc", ErrorKind::CrLf))));

/// assert_eq!(line_ending::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn line_ending<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  T: Compare<&'static str>,

{

  match input.compare("\n") {

    CompareResult::Ok => Ok(input.take_split(1)),

    CompareResult::Incomplete => Err(Err::Incomplete(Needed::new(1))),

    CompareResult::Error => {

      match input.compare("\r\n") {

        //FIXME: is this the right index?

        CompareResult::Ok => Ok(input.take_split(2)),

        CompareResult::Incomplete => Err(Err::Incomplete(Needed::new(2))),

        CompareResult::Error => Err(Err::Error(E::from_error_kind(input, ErrorKind::CrLf))),

      }

    }

  }

}

/// Matches a newline character '\\n'.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::newline;

/// assert_eq!(newline::<_, (_, ErrorKind)>("\nc"), Ok(("c", '\n')));

/// assert_eq!(newline::<_, (_, ErrorKind)>("\r\nc"), Err(Err::Error(("\r\nc", ErrorKind::Char))));

/// assert_eq!(newline::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn newline<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

{

  char('\n')(input)

}

/// Matches a tab character '\t'.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::tab;

/// assert_eq!(tab::<_, (_, ErrorKind)>("\tc"), Ok(("c", '\t')));

/// assert_eq!(tab::<_, (_, ErrorKind)>("\r\nc"), Err(Err::Error(("\r\nc", ErrorKind::Char))));

/// assert_eq!(tab::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn tab<I, Error: ParseError<I>>(input: I) -> IResult<I, char, Error>

where

  I: Input,

  <I as Input>::Item: AsChar,

{

  char('\t')(input)

}

/// Matches one element as a character.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data.

/// # Example

///

/// ```

/// # use nom::{character::streaming::anychar, Err, error::ErrorKind, IResult, Needed};

/// assert_eq!(anychar::<_, (_, ErrorKind)>("abc"), Ok(("bc",'a')));

/// assert_eq!(anychar::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn anychar<T, E: ParseError<T>>(input: T) -> IResult<T, char, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  let mut it = input.iter_elements();

  match it.next() {

    None => Err(Err::Incomplete(Needed::new(1))),

    Some(c) => Ok((input.take_from(c.len()), c.as_char())),

  }

}

/// Recognizes zero or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non alphabetic character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::alpha0;

/// assert_eq!(alpha0::<_, (_, ErrorKind)>("ab1c"), Ok(("1c", "ab")));

/// assert_eq!(alpha0::<_, (_, ErrorKind)>("1c"), Ok(("1c", "")));

/// assert_eq!(alpha0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn alpha0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_alpha())

}

/// Recognizes one or more lowercase and uppercase ASCII alphabetic characters: a-z, A-Z

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non alphabetic character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::alpha1;

/// assert_eq!(alpha1::<_, (_, ErrorKind)>("aB1c"), Ok(("1c", "aB")));

/// assert_eq!(alpha1::<_, (_, ErrorKind)>("1c"), Err(Err::Error(("1c", ErrorKind::Alpha))));

/// assert_eq!(alpha1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn alpha1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_alpha(), ErrorKind::Alpha)

}

/// Recognizes zero or more ASCII numerical characters: 0-9

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::digit0;

/// assert_eq!(digit0::<_, (_, ErrorKind)>("21c"), Ok(("c", "21")));

/// assert_eq!(digit0::<_, (_, ErrorKind)>("a21c"), Ok(("a21c", "")));

/// assert_eq!(digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_dec_digit())

}

/// Recognizes one or more ASCII numerical characters: 0-9

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::digit1;

/// assert_eq!(digit1::<_, (_, ErrorKind)>("21c"), Ok(("c", "21")));

/// assert_eq!(digit1::<_, (_, ErrorKind)>("c1"), Err(Err::Error(("c1", ErrorKind::Digit))));

/// assert_eq!(digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_dec_digit(), ErrorKind::Digit)

}

/// Recognizes zero or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non hexadecimal digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::hex_digit0;

/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>("21cZ"), Ok(("Z", "21c")));

/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));

/// assert_eq!(hex_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn hex_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_hex_digit())

}

/// Recognizes one or more ASCII hexadecimal numerical characters: 0-9, A-F, a-f

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non hexadecimal digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::hex_digit1;

/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>("21cZ"), Ok(("Z", "21c")));

/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::HexDigit))));

/// assert_eq!(hex_digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn hex_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_hex_digit(), ErrorKind::HexDigit)

}

/// Recognizes zero or more octal characters: 0-7

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non octal digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::oct_digit0;

/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>("21cZ"), Ok(("cZ", "21")));

/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));

/// assert_eq!(oct_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn oct_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_oct_digit())

}

/// Recognizes one or more octal characters: 0-7

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non octal digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::oct_digit1;

/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>("21cZ"), Ok(("cZ", "21")));

/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::OctDigit))));

/// assert_eq!(oct_digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn oct_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_oct_digit(), ErrorKind::OctDigit)

}

/// Recognizes zero or more binary characters: 0-1

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non binary digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::bin_digit0;

/// assert_eq!(bin_digit0::<_, (_, ErrorKind)>("013a"), Ok(("3a", "01")));

/// assert_eq!(bin_digit0::<_, (_, ErrorKind)>("a013"), Ok(("a013", "")));

/// assert_eq!(bin_digit0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn bin_digit0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_bin_digit())

}

/// Recognizes one or more binary characters: 0-1

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non binary digit character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::bin_digit1;

/// assert_eq!(bin_digit1::<_, (_, ErrorKind)>("013a"), Ok(("3a", "01")));

/// assert_eq!(bin_digit1::<_, (_, ErrorKind)>("a013"), Err(Err::Error(("a013", ErrorKind::BinDigit))));

/// assert_eq!(bin_digit1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn bin_digit1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_bin_digit(), ErrorKind::BinDigit)

}

/// Recognizes zero or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non alphanumerical character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::alphanumeric0;

/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>("21cZ%1"), Ok(("%1", "21cZ")));

/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>("&Z21c"), Ok(("&Z21c", "")));

/// assert_eq!(alphanumeric0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn alphanumeric0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| !item.is_alphanum())

}

/// Recognizes one or more ASCII numerical and alphabetic characters: 0-9, a-z, A-Z

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non alphanumerical character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::alphanumeric1;

/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>("21cZ%1"), Ok(("%1", "21cZ")));

/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>("&H2"), Err(Err::Error(("&H2", ErrorKind::AlphaNumeric))));

/// assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn alphanumeric1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(|item| !item.is_alphanum(), ErrorKind::AlphaNumeric)

}

/// Recognizes zero or more spaces and tabs.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non space character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::space0;

/// assert_eq!(space0::<_, (_, ErrorKind)>(" \t21c"), Ok(("21c", " \t")));

/// assert_eq!(space0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));

/// assert_eq!(space0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn space0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| {

    let c = item.as_char();

    !(c == ' ' || c == '\t')

  })

}

/// Recognizes one or more spaces and tabs.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non space character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::space1;

/// assert_eq!(space1::<_, (_, ErrorKind)>(" \t21c"), Ok(("21c", " \t")));

/// assert_eq!(space1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::Space))));

/// assert_eq!(space1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn space1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(

    |item| {

      let c = item.as_char();

      !(c == ' ' || c == '\t')

    },

    ErrorKind::Space,

  )

}

/// Recognizes zero or more spaces, tabs, carriage returns and line feeds.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non space character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::multispace0;

/// assert_eq!(multispace0::<_, (_, ErrorKind)>(" \t\n\r21c"), Ok(("21c", " \t\n\r")));

/// assert_eq!(multispace0::<_, (_, ErrorKind)>("Z21c"), Ok(("Z21c", "")));

/// assert_eq!(multispace0::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn multispace0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position(|item| {

    let c = item.as_char();

    !(c == ' ' || c == '\t' || c == '\r' || c == '\n')

  })

}

/// Recognizes one or more spaces, tabs, carriage returns and line feeds.

///

/// *Streaming version*: Will return `Err(nom::Err::Incomplete(_))` if there's not enough input data,

/// or if no terminating token is found (a non space character).

/// # Example

///

/// ```

/// # use nom::{Err, error::ErrorKind, IResult, Needed};

/// # use nom::character::streaming::multispace1;

/// assert_eq!(multispace1::<_, (_, ErrorKind)>(" \t\n\r21c"), Ok(("21c", " \t\n\r")));

/// assert_eq!(multispace1::<_, (_, ErrorKind)>("H2"), Err(Err::Error(("H2", ErrorKind::MultiSpace))));

/// assert_eq!(multispace1::<_, (_, ErrorKind)>(""), Err(Err::Incomplete(Needed::new(1))));

/// ```

pub fn multispace1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>

where

  T: Input,

  <T as Input>::Item: AsChar,

{

  input.split_at_position1(

    |item| {

      let c = item.as_char();

      !(c == ' ' || c == '\t' || c == '\r' || c == '\n')

    },

    ErrorKind::MultiSpace,

  )

}

pub(crate) fn sign<T, E: ParseError<T>>(input: T) -> IResult<T, bool, E>

where

  T: Clone + Input,

  T: for<'a> Compare<&'a [u8]>,

{

  use crate::bytes::streaming::tag;

  use crate::combinator::value;

  let (i, opt_sign) = opt(alt((

    value(false, tag(&b"-"[..])),

    value(true, tag(&b"+"[..])),

  )))

  .parse(input)?;

  let sign = opt_sign.unwrap_or(true);

  Ok((i, sign))

}

#[doc(hidden)]

macro_rules! ints {

    ($($t:tt)+) => {

        $(

        /// will parse a number in text form to a number

        ///

        /// *Complete version*: can parse until the end of input.

        pub fn $t<T, E: ParseError<T>>(input: T) -> IResult<T, $t, E>

            where

            T: Input +  Clone,

            <T as Input>::Item: AsChar,

            T: for <'a> Compare<&'a[u8]>,

            {

              let (i, sign) = sign(input.clone())?;

                if i.input_len() == 0 {

                    return Err(Err::Incomplete(Needed::new(1)));

                }

                let mut value: $t = 0;

                if sign {

                    let mut pos = 0;

                    for c in i.iter_elements() {

                        match c.as_char().to_digit(10) {

                            None => {

                                if pos == 0 {

                                    return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit)));

                                } else {

                                    return Ok((i.take_from(pos), value));

                                }

                            },

                            Some(d) => match value.checked_mul(10).and_then(|v| v.checked_add(d as $t)) {

Unexecuted instantiation: nom::character::streaming::i8::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::i16::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::i32::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::i64::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::i128::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::isize::<_, _>::{closure#0}

                                None => return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit))),

                                Some(v) => {

                                  pos += c.len();

                                  value = v;

                                },

                            }

                        }

                    }

                } else {

                    let mut pos = 0;

                    for c in i.iter_elements() {

                        match c.as_char().to_digit(10) {

                            None => {

                                if pos == 0 {

                                    return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit)));

                                } else {

                                    return Ok((i.take_from(pos), value));

                                }

                            },

                            Some(d) => match value.checked_mul(10).and_then(|v| v.checked_sub(d as $t)) {

Unexecuted instantiation: nom::character::streaming::i8::<_, _>::{closure#1}

Unexecuted instantiation: nom::character::streaming::i16::<_, _>::{closure#1}

Unexecuted instantiation: nom::character::streaming::i32::<_, _>::{closure#1}

Unexecuted instantiation: nom::character::streaming::i64::<_, _>::{closure#1}

Unexecuted instantiation: nom::character::streaming::i128::<_, _>::{closure#1}

Unexecuted instantiation: nom::character::streaming::isize::<_, _>::{closure#1}

                                None => return Err(Err::Error(E::from_error_kind(input, ErrorKind::Digit))),

                                Some(v) => {

                                  pos += c.len();

                                  value = v;

                                },

                            }

                        }

                    }

                }

                Err(Err::Incomplete(Needed::new(1)))

            }

Unexecuted instantiation: nom::character::streaming::i8::<_, _>

Unexecuted instantiation: nom::character::streaming::i16::<_, _>

Unexecuted instantiation: nom::character::streaming::i32::<_, _>

Unexecuted instantiation: nom::character::streaming::i64::<_, _>

Unexecuted instantiation: nom::character::streaming::i128::<_, _>

Unexecuted instantiation: nom::character::streaming::isize::<_, _>

        )+

    }

}

ints! { i8 i16 i32 i64 i128 isize }

#[doc(hidden)]

macro_rules! uints {

    ($($t:tt)+) => {

        $(

        /// will parse a number in text form to a number

        ///

        /// *Complete version*: can parse until the end of input.

        pub fn $t<T, E: ParseError<T>>(input: T) -> IResult<T, $t, E>

            where

            T: Input ,

            <T as Input>::Item: AsChar,

            {

                let i = input;

                if i.input_len() == 0 {

                    return Err(Err::Incomplete(Needed::new(1)));

                }

                let mut value: $t = 0;

                let mut pos = 0;

                for c in i.iter_elements() {

                    match c.as_char().to_digit(10) {

                        None => {

                            if pos == 0 {

                                return Err(Err::Error(E::from_error_kind(i, ErrorKind::Digit)));

                            } else {

                                return Ok((i.take_from(pos), value));

                            }

                        },

                        Some(d) => match value.checked_mul(10).and_then(|v| v.checked_add(d as $t)) {

Unexecuted instantiation: nom::character::streaming::u8::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::u16::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::u32::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::u64::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::u128::<_, _>::{closure#0}

Unexecuted instantiation: nom::character::streaming::usize::<_, _>::{closure#0}

                            None => return Err(Err::Error(E::from_error_kind(i, ErrorKind::Digit))),

                            Some(v) => {

                              pos += c.len();

                              value = v;

                            },

                        }

                    }

                }

                Err(Err::Incomplete(Needed::new(1)))

            }

Unexecuted instantiation: nom::character::streaming::u8::<_, _>

Unexecuted instantiation: nom::character::streaming::u16::<_, _>

Unexecuted instantiation: nom::character::streaming::u32::<_, _>

Unexecuted instantiation: nom::character::streaming::u64::<_, _>

Unexecuted instantiation: nom::character::streaming::u128::<_, _>

Unexecuted instantiation: nom::character::streaming::usize::<_, _>

        )+

    }

}

uints! { u8 u16 u32 u64 u128 usize }

#[cfg(test)]

mod tests {

  use super::*;

  use crate::error::ErrorKind;

  use crate::internal::{Err, Needed};

  use crate::sequence::pair;

  use crate::traits::ParseTo;

  use crate::Parser;

  use proptest::prelude::*;

  macro_rules! assert_parse(

    ($left: expr, $right: expr) => {

      let res: $crate::IResult<_, _, (_, ErrorKind)> = $left;

      assert_eq!(res, $right);

    };

  );

  #[test]

  fn anychar_str() {

    use super::anychar;

    assert_eq!(anychar::<_, (&str, ErrorKind)>("Ә"), Ok(("", 'Ә')));

  }

  #[test]

  fn character() {

    let a: &[u8] = b"abcd";

    let b: &[u8] = b"1234";

    let c: &[u8] = b"a123";

    let d: &[u8] = "azé12".as_bytes();

    let e: &[u8] = b" ";

    let f: &[u8] = b" ;";

    //assert_eq!(alpha1::<_, (_, ErrorKind)>(a), Err(Err::Incomplete(Needed::new(1))));

    assert_parse!(alpha1(a), Err(Err::Incomplete(Needed::new(1))));

    assert_eq!(alpha1(b), Err(Err::Error((b, ErrorKind::Alpha))));

    assert_eq!(alpha1::<_, (_, ErrorKind)>(c), Ok((&c[1..], &b"a"[..])));

    assert_eq!(

      alpha1::<_, (_, ErrorKind)>(d),

      Ok(("é12".as_bytes(), &b"az"[..]))

    );

    assert_eq!(digit1(a), Err(Err::Error((a, ErrorKind::Digit))));

    assert_eq!(

      digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(digit1(c), Err(Err::Error((c, ErrorKind::Digit))));

    assert_eq!(digit1(d), Err(Err::Error((d, ErrorKind::Digit))));

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(c),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(d),

      Ok(("zé12".as_bytes(), &b"a"[..]))

    );

    assert_eq!(hex_digit1(e), Err(Err::Error((e, ErrorKind::HexDigit))));

    assert_eq!(oct_digit1(a), Err(Err::Error((a, ErrorKind::OctDigit))));

    assert_eq!(

      oct_digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(oct_digit1(c), Err(Err::Error((c, ErrorKind::OctDigit))));

    assert_eq!(oct_digit1(d), Err(Err::Error((d, ErrorKind::OctDigit))));

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(bin_digit1(a), Err(Err::Error((a, ErrorKind::BinDigit))));

    assert_eq!(

      bin_digit1::<_, (_, ErrorKind)>(b),

      Ok((&b"234"[..], &b"1"[..]))

    );

    assert_eq!(bin_digit1(c), Err(Err::Error((c, ErrorKind::BinDigit))));

    assert_eq!(bin_digit1(d), Err(Err::Error((d, ErrorKind::BinDigit))));

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(c),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(d),

      Ok(("é12".as_bytes(), &b"az"[..]))

    );

    assert_eq!(

      space1::<_, (_, ErrorKind)>(e),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(space1::<_, (_, ErrorKind)>(f), Ok((&b";"[..], &b" "[..])));

  }

  #[cfg(feature = "alloc")]

  #[test]

  fn character_s() {

    let a = "abcd";

    let b = "1234";

    let c = "a123";

    let d = "azé12";

    let e = " ";

    assert_eq!(

      alpha1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(alpha1(b), Err(Err::Error((b, ErrorKind::Alpha))));

    assert_eq!(alpha1::<_, (_, ErrorKind)>(c), Ok((&c[1..], "a")));

    assert_eq!(alpha1::<_, (_, ErrorKind)>(d), Ok(("é12", "az")));

    assert_eq!(digit1(a), Err(Err::Error((a, ErrorKind::Digit))));

    assert_eq!(

      digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(digit1(c), Err(Err::Error((c, ErrorKind::Digit))));

    assert_eq!(digit1(d), Err(Err::Error((d, ErrorKind::Digit))));

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(

      hex_digit1::<_, (_, ErrorKind)>(c),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(hex_digit1::<_, (_, ErrorKind)>(d), Ok(("zé12", "a")));

    assert_eq!(hex_digit1(e), Err(Err::Error((e, ErrorKind::HexDigit))));

    assert_eq!(oct_digit1(a), Err(Err::Error((a, ErrorKind::OctDigit))));

    assert_eq!(

      oct_digit1::<_, (_, ErrorKind)>(b),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(oct_digit1(c), Err(Err::Error((c, ErrorKind::OctDigit))));

    assert_eq!(oct_digit1(d), Err(Err::Error((d, ErrorKind::OctDigit))));

    assert_eq!(bin_digit1(a), Err(Err::Error((a, ErrorKind::BinDigit))));

    assert_eq!(bin_digit1::<_, (_, ErrorKind)>(b), Ok(("234", "1")));

    assert_eq!(bin_digit1(c), Err(Err::Error((c, ErrorKind::BinDigit))));

    assert_eq!(bin_digit1(d), Err(Err::Error((d, ErrorKind::BinDigit))));

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(a),

      Err(Err::Incomplete(Needed::new(1)))

    );

    //assert_eq!(fix_error!(b,(), alphanumeric1), Ok((empty, b)));

    assert_eq!(

      alphanumeric1::<_, (_, ErrorKind)>(c),

      Err(Err::Incomplete(Needed::new(1)))

    );

    assert_eq!(alphanumeric1::<_, (_, ErrorKind)>(d), Ok(("é12", "az")));

    assert_eq!(

      space1::<_, (_, ErrorKind)>(e),

      Err(Err::Incomplete(Needed::new(1)))

    );

  }

  use crate::traits::Offset;

  #[test]

  fn offset() {

    let a = &b"abcd;"[..];

    let b = &b"1234;"[..];

    let c = &b"a123;"[..];

    let d = &b" \t;"[..];

    let e = &b" \t\r\n;"[..];

    let f = &b"123abcDEF;"[..];

    match alpha1::<_, (_, ErrorKind)>(a) {

      Ok((i, _)) => {

        assert_eq!(a.offset(i) + i.len(), a.len());

      }

      _ => panic!("wrong return type in offset test for alpha"),

    }

    match digit1::<_, (_, ErrorKind)>(b) {

      Ok((i, _)) => {

        assert_eq!(b.offset(i) + i.len(), b.len());

      }

      _ => panic!("wrong return type in offset test for digit"),

    }

    match alphanumeric1::<_, (_, ErrorKind)>(c) {

      Ok((i, _)) => {

        assert_eq!(c.offset(i) + i.len(), c.len());

      }

      _ => panic!("wrong return type in offset test for alphanumeric"),

    }

    match space1::<_, (_, ErrorKind)>(d) {

      Ok((i, _)) => {

        assert_eq!(d.offset(i) + i.len(), d.len());

      }

      _ => panic!("wrong return type in offset test for space"),

    }

    match multispace1::<_, (_, ErrorKind)>(e) {

      Ok((i, _)) => {

        assert_eq!(e.offset(i) + i.len(), e.len());

      }

      _ => panic!("wrong return type in offset test for multispace"),

    }

    match hex_digit1::<_, (_, ErrorKind)>(f) {

      Ok((i, _)) => {

        assert_eq!(f.offset(i) + i.len(), f.len());

      }

      _ => panic!("wrong return type in offset test for hex_digit"),

    }

    match oct_digit1::<_, (_, ErrorKind)>(f) {

      Ok((i, _)) => {

        assert_eq!(f.offset(i) + i.len(), f.len());

      }

      _ => panic!("wrong return type in offset test for oct_digit"),

    }

    match bin_digit1::<_, (_, ErrorKind)>(f) {

      Ok((i, _)) => {

        assert_eq!(f.offset(i) + i.len(), f.len());

      }

      _ => panic!("wrong return type in offset test for bin_digit"),

    }

  }

  #[test]

  fn is_not_line_ending_bytes() {

    let a: &[u8] = b"ab12cd\nefgh";

    assert_eq!(

      not_line_ending::<_, (_, ErrorKind)>(a),

      Ok((&b"\nefgh"[..], &b"ab12cd"[..]))

    );

    let b: &[u8] = b"ab12cd\nefgh\nijkl";

    assert_eq!(

      not_line_ending::<_, (_, ErrorKind)>(b),

      Ok((&b"\nefgh\nijkl"[..], &b"ab12cd"[..]))

    );

    let c: &[u8] = b"ab12cd\r\nefgh\nijkl";

    assert_eq!(

      not_line_ending::<_, (_, ErrorKind)>(c),

      Ok((&b"\r\nefgh\nijkl"[..], &b"ab12cd"[..]))

    );

    let d: &[u8] = b"ab12cd";

    assert_eq!(

      not_line_ending::<_, (_, ErrorKind)>(d),

      Err(Err::Incomplete(Needed::Unknown))

    );

  }

  #[test]