nom8/number/
mod.rs

1//! Parsers recognizing numbers
2
3#![allow(deprecated)] // will just become `pub(crate)` later
4
5pub mod complete;
6pub mod streaming;
7#[cfg(test)]
8mod tests;
9
10use crate::error::ParseError;
11use crate::input::{
12  AsBytes, AsChar, InputIsStreaming, InputIter, InputLength, InputTakeAtPosition, Slice,
13};
14use crate::lib::std::ops::{RangeFrom, RangeTo};
15use crate::IResult;
16
17/// Configurable endianness
18#[derive(Debug, PartialEq, Eq, Clone, Copy)]
19pub enum Endianness {
20  /// Big endian
21  Big,
22  /// Little endian
23  Little,
24  /// Will match the host's endianness
25  Native,
26}
27
28/// Recognizes an unsigned 1 byte integer.
29///
30/// *Complete version*: Returns an error if there is not enough input data.
31///
32/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
33///
34/// # Example
35///
36/// ```rust
37/// # use nom8::{Err, error::ErrorKind, Needed};
38/// # use nom8::Needed::Size;
39/// use nom8::number::be_u8;
40///
41/// let parser = |s| {
42///   be_u8(s)
43/// };
44///
45/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
46/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
47/// ```
48///
49/// ```rust
50/// # use nom8::{Err, error::ErrorKind, Needed};
51/// # use nom8::input::Streaming;
52/// use nom8::number::be_u8;
53///
54/// let parser = |s| {
55///   be_u8::<_, (_, ErrorKind), true>(s)
56/// };
57///
58/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"\x01abcd"[..]), 0x00)));
59/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
60/// ```
61#[inline(always)]
62pub fn be_u8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u8, E>
63where
64  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
65{
66  if STREAMING {
67    streaming::be_u8(input)
68  } else {
69    complete::be_u8(input)
70  }
71}
72
73/// Recognizes a big endian unsigned 2 bytes integer.
74///
75/// *Complete version*: Returns an error if there is not enough input data.
76///
77/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
78///
79/// # Example
80///
81/// ```rust
82/// # use nom8::{Err, error::ErrorKind, Needed};
83/// # use nom8::Needed::Size;
84/// use nom8::number::be_u16;
85///
86/// let parser = |s| {
87///   be_u16(s)
88/// };
89///
90/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
91/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
92/// ```
93///
94/// ```rust
95/// # use nom8::{Err, error::ErrorKind, Needed};
96/// # use nom8::input::Streaming;
97/// use nom8::number::be_u16;
98///
99/// let parser = |s| {
100///   be_u16::<_, (_, ErrorKind), true>(s)
101/// };
102///
103/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0001)));
104/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
105/// ```
106#[inline(always)]
107pub fn be_u16<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u16, E>
108where
109  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
110{
111  if STREAMING {
112    streaming::be_u16(input)
113  } else {
114    complete::be_u16(input)
115  }
116}
117
118/// Recognizes a big endian unsigned 3 byte integer.
119///
120/// *Complete version*: Returns an error if there is not enough input data.
121///
122/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
123///
124/// # Example
125///
126/// ```rust
127/// # use nom8::{Err, error::ErrorKind, Needed};
128/// # use nom8::Needed::Size;
129/// use nom8::number::be_u24;
130///
131/// let parser = |s| {
132///   be_u24(s)
133/// };
134///
135/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
136/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
137/// ```
138///
139/// ```rust
140/// # use nom8::{Err, error::ErrorKind, Needed};
141/// # use nom8::input::Streaming;
142/// use nom8::number::be_u24;
143///
144/// let parser = |s| {
145///   be_u24::<_, (_, ErrorKind), true>(s)
146/// };
147///
148/// assert_eq!(parser(Streaming(&b"\x00\x01\x02abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x000102)));
149/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
150/// ```
151#[inline(always)]
152pub fn be_u24<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u32, E>
153where
154  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
155{
156  if STREAMING {
157    streaming::be_u24(input)
158  } else {
159    complete::be_u24(input)
160  }
161}
162
163/// Recognizes a big endian unsigned 4 bytes integer.
164///
165/// *Complete version*: Returns an error if there is not enough input data.
166///
167/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
168///
169/// # Example
170///
171/// ```rust
172/// # use nom8::{Err, error::ErrorKind, Needed};
173/// # use nom8::Needed::Size;
174/// use nom8::number::be_u32;
175///
176/// let parser = |s| {
177///   be_u32(s)
178/// };
179///
180/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
181/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
182/// ```
183///
184/// ```rust
185/// # use nom8::{Err, error::ErrorKind, Needed};
186/// # use nom8::input::Streaming;
187/// use nom8::number::be_u32;
188///
189/// let parser = |s| {
190///   be_u32::<_, (_, ErrorKind), true>(s)
191/// };
192///
193/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x00010203)));
194/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
195/// ```
196#[inline(always)]
197pub fn be_u32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u32, E>
198where
199  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
200{
201  if STREAMING {
202    streaming::be_u32(input)
203  } else {
204    complete::be_u32(input)
205  }
206}
207
208/// Recognizes a big endian unsigned 8 bytes integer.
209///
210/// *Complete version*: Returns an error if there is not enough input data.
211///
212/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
213///
214/// # Example
215///
216/// ```rust
217/// # use nom8::{Err, error::ErrorKind, Needed};
218/// # use nom8::Needed::Size;
219/// use nom8::number::be_u64;
220///
221/// let parser = |s| {
222///   be_u64(s)
223/// };
224///
225/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
226/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
227/// ```
228///
229/// ```rust
230/// # use nom8::{Err, error::ErrorKind, Needed};
231/// # use nom8::input::Streaming;
232/// use nom8::number::be_u64;
233///
234/// let parser = |s| {
235///   be_u64::<_, (_, ErrorKind), true>(s)
236/// };
237///
238/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0001020304050607)));
239/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
240/// ```
241#[inline(always)]
242pub fn be_u64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u64, E>
243where
244  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
245{
246  if STREAMING {
247    streaming::be_u64(input)
248  } else {
249    complete::be_u64(input)
250  }
251}
252
253/// Recognizes a big endian unsigned 16 bytes integer.
254///
255/// *Complete version*: Returns an error if there is not enough input data.
256///
257/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
258///
259/// # Example
260///
261/// ```rust
262/// # use nom8::{Err, error::ErrorKind, Needed};
263/// # use nom8::Needed::Size;
264/// use nom8::number::be_u128;
265///
266/// let parser = |s| {
267///   be_u128(s)
268/// };
269///
270/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
271/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
272/// ```
273///
274/// ```rust
275/// # use nom8::{Err, error::ErrorKind, Needed};
276/// # use nom8::input::Streaming;
277/// use nom8::number::be_u128;
278///
279/// let parser = |s| {
280///   be_u128::<_, (_, ErrorKind), true>(s)
281/// };
282///
283/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x00010203040506070809101112131415)));
284/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
285/// ```
286#[inline(always)]
287pub fn be_u128<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u128, E>
288where
289  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
290{
291  if STREAMING {
292    streaming::be_u128(input)
293  } else {
294    complete::be_u128(input)
295  }
296}
297
298/// Recognizes a signed 1 byte integer.
299///
300/// *Complete version*: Returns an error if there is not enough input data.
301///
302/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
303///
304/// # Example
305///
306/// ```rust
307/// # use nom8::{Err, error::ErrorKind, Needed};
308/// # use nom8::Needed::Size;
309/// use nom8::number::be_i8;
310///
311/// let parser = |s| {
312///   be_i8(s)
313/// };
314///
315/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
316/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
317/// ```
318///
319/// ```rust
320/// # use nom8::{Err, error::ErrorKind, Needed};
321/// # use nom8::input::Streaming;
322/// use nom8::number::be_i8;
323///
324/// let parser = be_i8::<_, (_, ErrorKind), true>;
325///
326/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"\x01abcd"[..]), 0x00)));
327/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
328/// ```
329#[inline(always)]
330pub fn be_i8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i8, E>
331where
332  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
333{
334  if STREAMING {
335    streaming::be_i8(input)
336  } else {
337    complete::be_i8(input)
338  }
339}
340
341/// Recognizes a big endian signed 2 bytes integer.
342///
343/// *Complete version*: Returns an error if there is not enough input data.
344///
345/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
346///
347/// # Example
348///
349/// ```rust
350/// # use nom8::{Err, error::ErrorKind, Needed};
351/// # use nom8::Needed::Size;
352/// use nom8::number::be_i16;
353///
354/// let parser = |s| {
355///   be_i16(s)
356/// };
357///
358/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
359/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
360/// ```
361///
362/// ```rust
363/// # use nom8::{Err, error::ErrorKind, Needed};
364/// # use nom8::input::Streaming;
365/// use nom8::number::be_i16;
366///
367/// let parser = be_i16::<_, (_, ErrorKind), true>;
368///
369/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0001)));
370/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(2))));
371/// ```
372#[inline(always)]
373pub fn be_i16<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i16, E>
374where
375  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
376{
377  if STREAMING {
378    streaming::be_i16(input)
379  } else {
380    complete::be_i16(input)
381  }
382}
383
384/// Recognizes a big endian signed 3 bytes integer.
385///
386/// *Complete version*: Returns an error if there is not enough input data.
387///
388/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
389///
390/// # Example
391///
392/// ```rust
393/// # use nom8::{Err, error::ErrorKind, Needed};
394/// # use nom8::Needed::Size;
395/// use nom8::number::be_i24;
396///
397/// let parser = |s| {
398///   be_i24(s)
399/// };
400///
401/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
402/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
403/// ```
404///
405/// ```rust
406/// # use nom8::{Err, error::ErrorKind, Needed};
407/// # use nom8::input::Streaming;
408/// use nom8::number::be_i24;
409///
410/// let parser = be_i24::<_, (_, ErrorKind), true>;
411///
412/// assert_eq!(parser(Streaming(&b"\x00\x01\x02abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x000102)));
413/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(3))));
414/// ```
415#[inline(always)]
416pub fn be_i24<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i32, E>
417where
418  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
419{
420  if STREAMING {
421    streaming::be_i24(input)
422  } else {
423    complete::be_i24(input)
424  }
425}
426
427/// Recognizes a big endian signed 4 bytes integer.
428///
429/// *Complete version*: Teturns an error if there is not enough input data.
430///
431/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
432///
433/// # Example
434///
435/// ```rust
436/// # use nom8::{Err, error::ErrorKind, Needed};
437/// # use nom8::Needed::Size;
438/// use nom8::number::be_i32;
439///
440/// let parser = |s| {
441///   be_i32(s)
442/// };
443///
444/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
445/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
446/// ```
447///
448/// ```rust
449/// # use nom8::{Err, error::ErrorKind, Needed};
450/// # use nom8::input::Streaming;
451/// use nom8::number::be_i32;
452///
453/// let parser = be_i32::<_, (_, ErrorKind), true>;
454///
455/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x00010203)));
456/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(4))));
457/// ```
458#[inline(always)]
459pub fn be_i32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i32, E>
460where
461  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
462{
463  if STREAMING {
464    streaming::be_i32(input)
465  } else {
466    complete::be_i32(input)
467  }
468}
469
470/// Recognizes a big endian signed 8 bytes integer.
471///
472/// *Complete version*: Returns an error if there is not enough input data.
473///
474/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
475///
476/// # Example
477///
478/// ```rust
479/// # use nom8::{Err, error::ErrorKind, Needed};
480/// # use nom8::Needed::Size;
481/// use nom8::number::be_i64;
482///
483/// let parser = |s| {
484///   be_i64(s)
485/// };
486///
487/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
488/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
489/// ```
490///
491/// ```rust
492/// # use nom8::{Err, error::ErrorKind, Needed};
493/// # use nom8::input::Streaming;
494/// use nom8::number::be_i64;
495///
496/// let parser = be_i64::<_, (_, ErrorKind), true>;
497///
498/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0001020304050607)));
499/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
500/// ```
501#[inline(always)]
502pub fn be_i64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i64, E>
503where
504  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
505{
506  if STREAMING {
507    streaming::be_i64(input)
508  } else {
509    complete::be_i64(input)
510  }
511}
512
513/// Recognizes a big endian signed 16 bytes integer.
514///
515/// *Complete version*: Returns an error if there is not enough input data.
516///
517/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
518///
519/// # Example
520///
521/// ```rust
522/// # use nom8::{Err, error::ErrorKind, Needed};
523/// # use nom8::Needed::Size;
524/// use nom8::number::be_i128;
525///
526/// let parser = |s| {
527///   be_i128(s)
528/// };
529///
530/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
531/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
532/// ```
533///
534/// ```rust
535/// # use nom8::{Err, error::ErrorKind, Needed};
536/// # use nom8::input::Streaming;
537/// use nom8::number::be_i128;
538///
539/// let parser = be_i128::<_, (_, ErrorKind), true>;
540///
541/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x00010203040506070809101112131415)));
542/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
543/// ```
544#[inline(always)]
545pub fn be_i128<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i128, E>
546where
547  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
548{
549  if STREAMING {
550    streaming::be_i128(input)
551  } else {
552    complete::be_i128(input)
553  }
554}
555
556/// Recognizes an unsigned 1 byte integer.
557///
558/// *Complete version*: Returns an error if there is not enough input data.
559///
560/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
561///
562/// # Example
563///
564/// ```rust
565/// # use nom8::{Err, error::ErrorKind, Needed};
566/// # use nom8::Needed::Size;
567/// use nom8::number::le_u8;
568///
569/// let parser = |s| {
570///   le_u8(s)
571/// };
572///
573/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
574/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
575/// ```
576///
577/// ```rust
578/// # use nom8::{Err, error::ErrorKind, Needed};
579/// # use nom8::input::Streaming;
580/// use nom8::number::le_u8;
581///
582/// let parser = le_u8::<_, (_, ErrorKind), true>;
583///
584/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"\x01abcd"[..]), 0x00)));
585/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
586/// ```
587#[inline(always)]
588pub fn le_u8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u8, E>
589where
590  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
591{
592  if STREAMING {
593    streaming::le_u8(input)
594  } else {
595    complete::le_u8(input)
596  }
597}
598
599/// Recognizes a little endian unsigned 2 bytes integer.
600///
601/// *Complete version*: Returns an error if there is not enough input data.
602///
603/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
604///
605/// # Example
606///
607/// ```rust
608/// # use nom8::{Err, error::ErrorKind, Needed};
609/// # use nom8::Needed::Size;
610/// use nom8::number::le_u16;
611///
612/// let parser = |s| {
613///   le_u16(s)
614/// };
615///
616/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
617/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
618/// ```
619///
620/// ```rust
621/// # use nom8::{Err, error::ErrorKind, Needed};
622/// # use nom8::input::Streaming;
623/// use nom8::number::le_u16;
624///
625/// let parser = |s| {
626///   le_u16::<_, (_, ErrorKind), true>(s)
627/// };
628///
629/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0100)));
630/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
631/// ```
632#[inline(always)]
633pub fn le_u16<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u16, E>
634where
635  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
636{
637  if STREAMING {
638    streaming::le_u16(input)
639  } else {
640    complete::le_u16(input)
641  }
642}
643
644/// Recognizes a little endian unsigned 3 byte integer.
645///
646/// *Complete version*: Returns an error if there is not enough input data.
647///
648/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
649///
650/// # Example
651///
652/// ```rust
653/// # use nom8::{Err, error::ErrorKind, Needed};
654/// # use nom8::Needed::Size;
655/// use nom8::number::le_u24;
656///
657/// let parser = |s| {
658///   le_u24(s)
659/// };
660///
661/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
662/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
663/// ```
664///
665/// ```rust
666/// # use nom8::{Err, error::ErrorKind, Needed};
667/// # use nom8::input::Streaming;
668/// use nom8::number::le_u24;
669///
670/// let parser = |s| {
671///   le_u24::<_, (_, ErrorKind), true>(s)
672/// };
673///
674/// assert_eq!(parser(Streaming(&b"\x00\x01\x02abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x020100)));
675/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
676/// ```
677#[inline(always)]
678pub fn le_u24<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u32, E>
679where
680  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
681{
682  if STREAMING {
683    streaming::le_u24(input)
684  } else {
685    complete::le_u24(input)
686  }
687}
688
689/// Recognizes a little endian unsigned 4 bytes integer.
690///
691/// *Complete version*: Returns an error if there is not enough input data.
692///
693/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
694///
695/// # Example
696///
697/// ```rust
698/// # use nom8::{Err, error::ErrorKind, Needed};
699/// # use nom8::Needed::Size;
700/// use nom8::number::le_u32;
701///
702/// let parser = |s| {
703///   le_u32(s)
704/// };
705///
706/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
707/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
708/// ```
709///
710/// ```rust
711/// # use nom8::{Err, error::ErrorKind, Needed};
712/// # use nom8::input::Streaming;
713/// use nom8::number::le_u32;
714///
715/// let parser = |s| {
716///   le_u32::<_, (_, ErrorKind), true>(s)
717/// };
718///
719/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x03020100)));
720/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
721/// ```
722#[inline(always)]
723pub fn le_u32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u32, E>
724where
725  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
726{
727  if STREAMING {
728    streaming::le_u32(input)
729  } else {
730    complete::le_u32(input)
731  }
732}
733
734/// Recognizes a little endian unsigned 8 bytes integer.
735///
736/// *Complete version*: Returns an error if there is not enough input data.
737///
738/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
739///
740/// # Example
741///
742/// ```rust
743/// # use nom8::{Err, error::ErrorKind, Needed};
744/// # use nom8::Needed::Size;
745/// use nom8::number::le_u64;
746///
747/// let parser = |s| {
748///   le_u64(s)
749/// };
750///
751/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
752/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
753/// ```
754///
755/// ```rust
756/// # use nom8::{Err, error::ErrorKind, Needed};
757/// # use nom8::input::Streaming;
758/// use nom8::number::le_u64;
759///
760/// let parser = |s| {
761///   le_u64::<_, (_, ErrorKind), true>(s)
762/// };
763///
764/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0706050403020100)));
765/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
766/// ```
767#[inline(always)]
768pub fn le_u64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u64, E>
769where
770  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
771{
772  if STREAMING {
773    streaming::le_u64(input)
774  } else {
775    complete::le_u64(input)
776  }
777}
778
779/// Recognizes a little endian unsigned 16 bytes integer.
780///
781/// *Complete version*: Returns an error if there is not enough input data.
782///
783/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
784///
785/// # Example
786///
787/// ```rust
788/// # use nom8::{Err, error::ErrorKind, Needed};
789/// # use nom8::Needed::Size;
790/// use nom8::number::le_u128;
791///
792/// let parser = |s| {
793///   le_u128(s)
794/// };
795///
796/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
797/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
798/// ```
799///
800/// ```rust
801/// # use nom8::{Err, error::ErrorKind, Needed};
802/// # use nom8::input::Streaming;
803/// use nom8::number::le_u128;
804///
805/// let parser = |s| {
806///   le_u128::<_, (_, ErrorKind), true>(s)
807/// };
808///
809/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x15141312111009080706050403020100)));
810/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
811/// ```
812#[inline(always)]
813pub fn le_u128<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u128, E>
814where
815  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
816{
817  if STREAMING {
818    streaming::le_u128(input)
819  } else {
820    complete::le_u128(input)
821  }
822}
823
824/// Recognizes a signed 1 byte integer.
825///
826/// *Complete version*: Returns an error if there is not enough input data.
827///
828/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
829///
830/// # Example
831///
832/// ```rust
833/// # use nom8::{Err, error::ErrorKind, Needed};
834/// # use nom8::Needed::Size;
835/// use nom8::number::le_i8;
836///
837/// let parser = |s| {
838///   le_i8(s)
839/// };
840///
841/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
842/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
843/// ```
844///
845/// ```rust
846/// # use nom8::{Err, error::ErrorKind, Needed};
847/// # use nom8::input::Streaming;
848/// use nom8::number::le_i8;
849///
850/// let parser = le_i8::<_, (_, ErrorKind), true>;
851///
852/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"\x01abcd"[..]), 0x00)));
853/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
854/// ```
855#[inline(always)]
856pub fn le_i8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i8, E>
857where
858  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
859{
860  if STREAMING {
861    streaming::le_i8(input)
862  } else {
863    complete::le_i8(input)
864  }
865}
866
867/// Recognizes a little endian signed 2 bytes integer.
868///
869/// *Complete version*: Returns an error if there is not enough input data.
870///
871/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
872///
873/// # Example
874///
875/// ```rust
876/// # use nom8::{Err, error::ErrorKind, Needed};
877/// # use nom8::Needed::Size;
878/// use nom8::number::le_i16;
879///
880/// let parser = |s| {
881///   le_i16(s)
882/// };
883///
884/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
885/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
886/// ```
887///
888/// ```rust
889/// # use nom8::{Err, error::ErrorKind, Needed};
890/// # use nom8::input::Streaming;
891/// use nom8::number::le_i16;
892///
893/// let parser = |s| {
894///   le_i16::<_, (_, ErrorKind), true>(s)
895/// };
896///
897/// assert_eq!(parser(Streaming(&b"\x00\x01abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0100)));
898/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
899/// ```
900#[inline(always)]
901pub fn le_i16<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i16, E>
902where
903  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
904{
905  if STREAMING {
906    streaming::le_i16(input)
907  } else {
908    complete::le_i16(input)
909  }
910}
911
912/// Recognizes a little endian signed 3 bytes integer.
913///
914/// *Complete version*: Returns an error if there is not enough input data.
915///
916/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
917///
918/// # Example
919///
920/// ```rust
921/// # use nom8::{Err, error::ErrorKind, Needed};
922/// # use nom8::Needed::Size;
923/// use nom8::number::le_i24;
924///
925/// let parser = |s| {
926///   le_i24(s)
927/// };
928///
929/// assert_eq!(parser(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
930/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
931/// ```
932///
933/// ```rust
934/// # use nom8::{Err, error::ErrorKind, Needed};
935/// # use nom8::input::Streaming;
936/// use nom8::number::le_i24;
937///
938/// let parser = |s| {
939///   le_i24::<_, (_, ErrorKind), true>(s)
940/// };
941///
942/// assert_eq!(parser(Streaming(&b"\x00\x01\x02abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x020100)));
943/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
944/// ```
945#[inline(always)]
946pub fn le_i24<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i32, E>
947where
948  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
949{
950  if STREAMING {
951    streaming::le_i24(input)
952  } else {
953    complete::le_i24(input)
954  }
955}
956
957/// Recognizes a little endian signed 4 bytes integer.
958///
959/// *Complete version*: Returns an error if there is not enough input data.
960///
961/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
962///
963/// # Example
964///
965/// ```rust
966/// # use nom8::{Err, error::ErrorKind, Needed};
967/// # use nom8::Needed::Size;
968/// use nom8::number::le_i32;
969///
970/// let parser = |s| {
971///   le_i32(s)
972/// };
973///
974/// assert_eq!(parser(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
975/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
976/// ```
977///
978/// ```rust
979/// # use nom8::{Err, error::ErrorKind, Needed};
980/// # use nom8::input::Streaming;
981/// use nom8::number::le_i32;
982///
983/// let parser = |s| {
984///   le_i32::<_, (_, ErrorKind), true>(s)
985/// };
986///
987/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x03020100)));
988/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
989/// ```
990#[inline(always)]
991pub fn le_i32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i32, E>
992where
993  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
994{
995  if STREAMING {
996    streaming::le_i32(input)
997  } else {
998    complete::le_i32(input)
999  }
1000}
1001
1002/// Recognizes a little endian signed 8 bytes integer.
1003///
1004/// *Complete version*: Returns an error if there is not enough input data.
1005///
1006/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1007///
1008/// # Example
1009///
1010/// ```rust
1011/// # use nom8::{Err, error::ErrorKind, Needed};
1012/// # use nom8::Needed::Size;
1013/// use nom8::number::le_i64;
1014///
1015/// let parser = |s| {
1016///   le_i64(s)
1017/// };
1018///
1019/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
1020/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1021/// ```
1022///
1023/// ```rust
1024/// # use nom8::{Err, error::ErrorKind, Needed};
1025/// # use nom8::input::Streaming;
1026/// use nom8::number::le_i64;
1027///
1028/// let parser = |s| {
1029///   le_i64::<_, (_, ErrorKind), true>(s)
1030/// };
1031///
1032/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x0706050403020100)));
1033/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
1034/// ```
1035#[inline(always)]
1036pub fn le_i64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i64, E>
1037where
1038  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1039{
1040  if STREAMING {
1041    streaming::le_i64(input)
1042  } else {
1043    complete::le_i64(input)
1044  }
1045}
1046
1047/// Recognizes a little endian signed 16 bytes integer.
1048///
1049/// *Complete version*: Returns an error if there is not enough input data.
1050///
1051/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1052///
1053/// # Example
1054///
1055/// ```rust
1056/// # use nom8::{Err, error::ErrorKind, Needed};
1057/// # use nom8::Needed::Size;
1058/// use nom8::number::le_i128;
1059///
1060/// let parser = |s| {
1061///   le_i128(s)
1062/// };
1063///
1064/// assert_eq!(parser(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
1065/// assert_eq!(parser(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1066/// ```
1067///
1068/// ```rust
1069/// # use nom8::{Err, error::ErrorKind, Needed};
1070/// # use nom8::input::Streaming;
1071/// use nom8::number::le_i128;
1072///
1073/// let parser = |s| {
1074///   le_i128::<_, (_, ErrorKind), true>(s)
1075/// };
1076///
1077/// assert_eq!(parser(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15abcd"[..])), Ok((Streaming(&b"abcd"[..]), 0x15141312111009080706050403020100)));
1078/// assert_eq!(parser(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
1079/// ```
1080#[inline(always)]
1081pub fn le_i128<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i128, E>
1082where
1083  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1084{
1085  if STREAMING {
1086    streaming::le_i128(input)
1087  } else {
1088    complete::le_i128(input)
1089  }
1090}
1091
1092/// Recognizes an unsigned 1 byte integer
1093///
1094/// **Note:** that endianness does not apply to 1 byte numbers.
1095///
1096/// *Complete version*: returns an error if there is not enough input data
1097///
1098/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1099///
1100/// # Example
1101///
1102/// ```rust
1103/// # use nom8::{Err, error::ErrorKind, Needed};
1104/// # use nom8::Needed::Size;
1105/// use nom8::number::u8;
1106///
1107/// let parser = |s| {
1108///   u8(s)
1109/// };
1110///
1111/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
1112/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
1113/// ```
1114///
1115/// ```rust
1116/// # use nom8::{Err, error::ErrorKind, Needed};
1117/// # use nom8::Needed::Size;
1118/// # use nom8::input::Streaming;
1119/// use nom8::number::u8;
1120///
1121/// let parser = |s| {
1122///   u8::<_, (_, ErrorKind), true>(s)
1123/// };
1124///
1125/// assert_eq!(parser(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"\x03abcefg"[..]), 0x00)));
1126/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
1127/// ```
1128#[inline(always)]
1129pub fn u8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u8, E>
1130where
1131  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1132{
1133  if STREAMING {
1134    streaming::u8(input)
1135  } else {
1136    complete::u8(input)
1137  }
1138}
1139
1140/// Recognizes an unsigned 2 bytes integer
1141///
1142/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian u16 integer,
1143/// otherwise if `nom8::number::Endianness::Little` parse a little endian u16 integer.
1144///
1145/// *Complete version*: returns an error if there is not enough input data
1146///
1147/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1148///
1149/// # Example
1150///
1151/// ```rust
1152/// # use nom8::{Err, error::ErrorKind, Needed};
1153/// # use nom8::Needed::Size;
1154/// use nom8::number::u16;
1155///
1156/// let be_u16 = |s| {
1157///   u16(nom8::number::Endianness::Big)(s)
1158/// };
1159///
1160/// assert_eq!(be_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
1161/// assert_eq!(be_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1162///
1163/// let le_u16 = |s| {
1164///   u16(nom8::number::Endianness::Little)(s)
1165/// };
1166///
1167/// assert_eq!(le_u16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
1168/// assert_eq!(le_u16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1169/// ```
1170///
1171/// ```rust
1172/// # use nom8::{Err, error::ErrorKind, Needed};
1173/// # use nom8::Needed::Size;
1174/// # use nom8::input::Streaming;
1175/// use nom8::number::u16;
1176///
1177/// let be_u16 = |s| {
1178///   u16::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1179/// };
1180///
1181/// assert_eq!(be_u16(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0003)));
1182/// assert_eq!(be_u16(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
1183///
1184/// let le_u16 = |s| {
1185///   u16::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1186/// };
1187///
1188/// assert_eq!(le_u16(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0300)));
1189/// assert_eq!(le_u16(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
1190/// ```
1191#[inline(always)]
1192pub fn u16<I, E: ParseError<I>, const STREAMING: bool>(
1193  endian: crate::number::Endianness,
1194) -> fn(I) -> IResult<I, u16, E>
1195where
1196  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1197{
1198  if STREAMING {
1199    streaming::u16(endian)
1200  } else {
1201    complete::u16(endian)
1202  }
1203}
1204
1205/// Recognizes an unsigned 3 byte integer
1206///
1207/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian u24 integer,
1208/// otherwise if `nom8::number::Endianness::Little` parse a little endian u24 integer.
1209///
1210/// *Complete version*: returns an error if there is not enough input data
1211///
1212/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1213///
1214/// # Example
1215///
1216/// ```rust
1217/// # use nom8::{Err, error::ErrorKind, Needed};
1218/// # use nom8::Needed::Size;
1219/// use nom8::number::u24;
1220///
1221/// let be_u24 = |s| {
1222///   u24(nom8::number::Endianness::Big)(s)
1223/// };
1224///
1225/// assert_eq!(be_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
1226/// assert_eq!(be_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1227///
1228/// let le_u24 = |s| {
1229///   u24(nom8::number::Endianness::Little)(s)
1230/// };
1231///
1232/// assert_eq!(le_u24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
1233/// assert_eq!(le_u24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1234/// ```
1235///
1236/// ```rust
1237/// # use nom8::{Err, error::ErrorKind, Needed};
1238/// # use nom8::Needed::Size;
1239/// # use nom8::input::Streaming;
1240/// use nom8::number::u24;
1241///
1242/// let be_u24 = |s| {
1243///   u24::<_,(_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1244/// };
1245///
1246/// assert_eq!(be_u24(Streaming(&b"\x00\x03\x05abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x000305)));
1247/// assert_eq!(be_u24(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
1248///
1249/// let le_u24 = |s| {
1250///   u24::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1251/// };
1252///
1253/// assert_eq!(le_u24(Streaming(&b"\x00\x03\x05abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x050300)));
1254/// assert_eq!(le_u24(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
1255/// ```
1256#[inline(always)]
1257pub fn u24<I, E: ParseError<I>, const STREAMING: bool>(
1258  endian: crate::number::Endianness,
1259) -> fn(I) -> IResult<I, u32, E>
1260where
1261  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1262{
1263  if STREAMING {
1264    streaming::u24(endian)
1265  } else {
1266    complete::u24(endian)
1267  }
1268}
1269
1270/// Recognizes an unsigned 4 byte integer
1271///
1272/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian u32 integer,
1273/// otherwise if `nom8::number::Endianness::Little` parse a little endian u32 integer.
1274///
1275/// *Complete version*: returns an error if there is not enough input data
1276///
1277/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1278///
1279/// # Example
1280///
1281/// ```rust
1282/// # use nom8::{Err, error::ErrorKind, Needed};
1283/// # use nom8::Needed::Size;
1284/// use nom8::number::u32;
1285///
1286/// let be_u32 = |s| {
1287///   u32(nom8::number::Endianness::Big)(s)
1288/// };
1289///
1290/// assert_eq!(be_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
1291/// assert_eq!(be_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1292///
1293/// let le_u32 = |s| {
1294///   u32(nom8::number::Endianness::Little)(s)
1295/// };
1296///
1297/// assert_eq!(le_u32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
1298/// assert_eq!(le_u32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1299/// ```
1300///
1301/// ```rust
1302/// # use nom8::{Err, error::ErrorKind, Needed};
1303/// # use nom8::Needed::Size;
1304/// # use nom8::input::Streaming;
1305/// use nom8::number::u32;
1306///
1307/// let be_u32 = |s| {
1308///   u32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1309/// };
1310///
1311/// assert_eq!(be_u32(Streaming(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x00030507)));
1312/// assert_eq!(be_u32(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
1313///
1314/// let le_u32 = |s| {
1315///   u32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1316/// };
1317///
1318/// assert_eq!(le_u32(Streaming(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x07050300)));
1319/// assert_eq!(le_u32(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
1320/// ```
1321#[inline(always)]
1322pub fn u32<I, E: ParseError<I>, const STREAMING: bool>(
1323  endian: crate::number::Endianness,
1324) -> fn(I) -> IResult<I, u32, E>
1325where
1326  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1327{
1328  if STREAMING {
1329    streaming::u32(endian)
1330  } else {
1331    complete::u32(endian)
1332  }
1333}
1334
1335/// Recognizes an unsigned 8 byte integer
1336///
1337/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian u64 integer,
1338/// otherwise if `nom8::number::Endianness::Little` parse a little endian u64 integer.
1339///
1340/// *Complete version*: returns an error if there is not enough input data
1341///
1342/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1343///
1344/// # Example
1345///
1346/// ```rust
1347/// # use nom8::{Err, error::ErrorKind, Needed};
1348/// # use nom8::Needed::Size;
1349/// use nom8::number::u64;
1350///
1351/// let be_u64 = |s| {
1352///   u64(nom8::number::Endianness::Big)(s)
1353/// };
1354///
1355/// assert_eq!(be_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
1356/// assert_eq!(be_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1357///
1358/// let le_u64 = |s| {
1359///   u64(nom8::number::Endianness::Little)(s)
1360/// };
1361///
1362/// assert_eq!(le_u64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
1363/// assert_eq!(le_u64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1364/// ```
1365///
1366/// ```rust
1367/// # use nom8::{Err, error::ErrorKind, Needed};
1368/// # use nom8::Needed::Size;
1369/// # use nom8::input::Streaming;
1370/// use nom8::number::u64;
1371///
1372/// let be_u64 = |s| {
1373///   u64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1374/// };
1375///
1376/// assert_eq!(be_u64(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0001020304050607)));
1377/// assert_eq!(be_u64(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
1378///
1379/// let le_u64 = |s| {
1380///   u64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1381/// };
1382///
1383/// assert_eq!(le_u64(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0706050403020100)));
1384/// assert_eq!(le_u64(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
1385/// ```
1386#[inline(always)]
1387pub fn u64<I, E: ParseError<I>, const STREAMING: bool>(
1388  endian: crate::number::Endianness,
1389) -> fn(I) -> IResult<I, u64, E>
1390where
1391  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1392{
1393  if STREAMING {
1394    streaming::u64(endian)
1395  } else {
1396    complete::u64(endian)
1397  }
1398}
1399
1400/// Recognizes an unsigned 16 byte integer
1401///
1402/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian u128 integer,
1403/// otherwise if `nom8::number::Endianness::Little` parse a little endian u128 integer.
1404///
1405/// *Complete version*: returns an error if there is not enough input data
1406///
1407/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1408///
1409/// # Example
1410///
1411/// ```rust
1412/// # use nom8::{Err, error::ErrorKind, Needed};
1413/// # use nom8::Needed::Size;
1414/// use nom8::number::u128;
1415///
1416/// let be_u128 = |s| {
1417///   u128(nom8::number::Endianness::Big)(s)
1418/// };
1419///
1420/// assert_eq!(be_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
1421/// assert_eq!(be_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1422///
1423/// let le_u128 = |s| {
1424///   u128(nom8::number::Endianness::Little)(s)
1425/// };
1426///
1427/// assert_eq!(le_u128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
1428/// assert_eq!(le_u128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1429/// ```
1430///
1431/// ```rust
1432/// # use nom8::{Err, error::ErrorKind, Needed};
1433/// # use nom8::Needed::Size;
1434/// # use nom8::input::Streaming;
1435/// use nom8::number::u128;
1436///
1437/// let be_u128 = |s| {
1438///   u128::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1439/// };
1440///
1441/// assert_eq!(be_u128(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x00010203040506070001020304050607)));
1442/// assert_eq!(be_u128(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
1443///
1444/// let le_u128 = |s| {
1445///   u128::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1446/// };
1447///
1448/// assert_eq!(le_u128(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x07060504030201000706050403020100)));
1449/// assert_eq!(le_u128(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
1450/// ```
1451#[inline(always)]
1452pub fn u128<I, E: ParseError<I>, const STREAMING: bool>(
1453  endian: crate::number::Endianness,
1454) -> fn(I) -> IResult<I, u128, E>
1455where
1456  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1457{
1458  if STREAMING {
1459    streaming::u128(endian)
1460  } else {
1461    complete::u128(endian)
1462  }
1463}
1464
1465/// Recognizes a signed 1 byte integer
1466///
1467/// **Note:** that endianness does not apply to 1 byte numbers.
1468///
1469/// *Complete version*: returns an error if there is not enough input data
1470///
1471/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1472///
1473/// # Example
1474///
1475/// ```rust
1476/// # use nom8::{Err, error::ErrorKind, Needed};
1477/// # use nom8::Needed::Size;
1478/// use nom8::number::i8;
1479///
1480/// let parser = |s| {
1481///   i8(s)
1482/// };
1483///
1484/// assert_eq!(parser(&b"\x00\x03abcefg"[..]), Ok((&b"\x03abcefg"[..], 0x00)));
1485/// assert_eq!(parser(&b""[..]), Err(Err::Error((&[][..], ErrorKind::Eof))));
1486/// ```
1487///
1488/// ```rust
1489/// # use nom8::{Err, error::ErrorKind, Needed};
1490/// # use nom8::Needed::Size;
1491/// # use nom8::input::Streaming;
1492/// use nom8::number::i8;
1493///
1494/// let parser = |s| {
1495///   i8::<_, (_, ErrorKind), true>(s)
1496/// };
1497///
1498/// assert_eq!(parser(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"\x03abcefg"[..]), 0x00)));
1499/// assert_eq!(parser(Streaming(&b""[..])), Err(Err::Incomplete(Needed::new(1))));
1500/// ```
1501#[inline(always)]
1502pub fn i8<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, i8, E>
1503where
1504  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1505{
1506  if STREAMING {
1507    streaming::i8(input)
1508  } else {
1509    complete::i8(input)
1510  }
1511}
1512
1513/// Recognizes a signed 2 byte integer
1514///
1515/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian i16 integer,
1516/// otherwise if `nom8::number::Endianness::Little` parse a little endian i16 integer.
1517///
1518/// *Complete version*: returns an error if there is not enough input data
1519///
1520/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1521///
1522/// # Example
1523///
1524/// ```rust
1525/// # use nom8::{Err, error::ErrorKind, Needed};
1526/// # use nom8::Needed::Size;
1527/// use nom8::number::i16;
1528///
1529/// let be_i16 = |s| {
1530///   i16(nom8::number::Endianness::Big)(s)
1531/// };
1532///
1533/// assert_eq!(be_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0003)));
1534/// assert_eq!(be_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1535///
1536/// let le_i16 = |s| {
1537///   i16(nom8::number::Endianness::Little)(s)
1538/// };
1539///
1540/// assert_eq!(le_i16(&b"\x00\x03abcefg"[..]), Ok((&b"abcefg"[..], 0x0300)));
1541/// assert_eq!(le_i16(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1542/// ```
1543///
1544/// ```rust
1545/// # use nom8::{Err, error::ErrorKind, Needed};
1546/// # use nom8::Needed::Size;
1547/// # use nom8::input::Streaming;
1548/// use nom8::number::i16;
1549///
1550/// let be_i16 = |s| {
1551///   i16::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1552/// };
1553///
1554/// assert_eq!(be_i16(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0003)));
1555/// assert_eq!(be_i16(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
1556///
1557/// let le_i16 = |s| {
1558///   i16::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1559/// };
1560///
1561/// assert_eq!(le_i16(Streaming(&b"\x00\x03abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0300)));
1562/// assert_eq!(le_i16(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(1))));
1563/// ```
1564#[inline(always)]
1565pub fn i16<I, E: ParseError<I>, const STREAMING: bool>(
1566  endian: crate::number::Endianness,
1567) -> fn(I) -> IResult<I, i16, E>
1568where
1569  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1570{
1571  if STREAMING {
1572    streaming::i16(endian)
1573  } else {
1574    complete::i16(endian)
1575  }
1576}
1577
1578/// Recognizes a signed 3 byte integer
1579///
1580/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian i24 integer,
1581/// otherwise if `nom8::number::Endianness::Little` parse a little endian i24 integer.
1582///
1583/// *Complete version*: returns an error if there is not enough input data
1584///
1585/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1586///
1587/// # Example
1588///
1589/// ```rust
1590/// # use nom8::{Err, error::ErrorKind, Needed};
1591/// # use nom8::Needed::Size;
1592/// use nom8::number::i24;
1593///
1594/// let be_i24 = |s| {
1595///   i24(nom8::number::Endianness::Big)(s)
1596/// };
1597///
1598/// assert_eq!(be_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x000305)));
1599/// assert_eq!(be_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1600///
1601/// let le_i24 = |s| {
1602///   i24(nom8::number::Endianness::Little)(s)
1603/// };
1604///
1605/// assert_eq!(le_i24(&b"\x00\x03\x05abcefg"[..]), Ok((&b"abcefg"[..], 0x050300)));
1606/// assert_eq!(le_i24(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1607/// ```
1608///
1609/// ```rust
1610/// # use nom8::{Err, error::ErrorKind, Needed};
1611/// # use nom8::Needed::Size;
1612/// # use nom8::input::Streaming;
1613/// use nom8::number::i24;
1614///
1615/// let be_i24 = |s| {
1616///   i24::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1617/// };
1618///
1619/// assert_eq!(be_i24(Streaming(&b"\x00\x03\x05abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x000305)));
1620/// assert_eq!(be_i24(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
1621///
1622/// let le_i24 = |s| {
1623///   i24::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1624/// };
1625///
1626/// assert_eq!(le_i24(Streaming(&b"\x00\x03\x05abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x050300)));
1627/// assert_eq!(le_i24(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(2))));
1628/// ```
1629#[inline(always)]
1630pub fn i24<I, E: ParseError<I>, const STREAMING: bool>(
1631  endian: crate::number::Endianness,
1632) -> fn(I) -> IResult<I, i32, E>
1633where
1634  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1635{
1636  if STREAMING {
1637    streaming::i24(endian)
1638  } else {
1639    complete::i24(endian)
1640  }
1641}
1642
1643/// Recognizes a signed 4 byte integer
1644///
1645/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian i32 integer,
1646/// otherwise if `nom8::number::Endianness::Little` parse a little endian i32 integer.
1647///
1648/// *Complete version*: returns an error if there is not enough input data
1649///
1650/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1651///
1652/// # Example
1653///
1654/// ```rust
1655/// # use nom8::{Err, error::ErrorKind, Needed};
1656/// # use nom8::Needed::Size;
1657/// use nom8::number::i32;
1658///
1659/// let be_i32 = |s| {
1660///   i32(nom8::number::Endianness::Big)(s)
1661/// };
1662///
1663/// assert_eq!(be_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00030507)));
1664/// assert_eq!(be_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1665///
1666/// let le_i32 = |s| {
1667///   i32(nom8::number::Endianness::Little)(s)
1668/// };
1669///
1670/// assert_eq!(le_i32(&b"\x00\x03\x05\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07050300)));
1671/// assert_eq!(le_i32(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1672/// ```
1673///
1674/// ```rust
1675/// # use nom8::{Err, error::ErrorKind, Needed};
1676/// # use nom8::Needed::Size;
1677/// # use nom8::input::Streaming;
1678/// use nom8::number::i32;
1679///
1680/// let be_i32 = |s| {
1681///   i32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1682/// };
1683///
1684/// assert_eq!(be_i32(Streaming(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x00030507)));
1685/// assert_eq!(be_i32(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
1686///
1687/// let le_i32 = |s| {
1688///   i32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1689/// };
1690///
1691/// assert_eq!(le_i32(Streaming(&b"\x00\x03\x05\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x07050300)));
1692/// assert_eq!(le_i32(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(3))));
1693/// ```
1694#[inline(always)]
1695pub fn i32<I, E: ParseError<I>, const STREAMING: bool>(
1696  endian: crate::number::Endianness,
1697) -> fn(I) -> IResult<I, i32, E>
1698where
1699  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1700{
1701  if STREAMING {
1702    streaming::i32(endian)
1703  } else {
1704    complete::i32(endian)
1705  }
1706}
1707
1708/// Recognizes a signed 8 byte integer
1709///
1710/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian i64 integer,
1711/// otherwise if `nom8::number::Endianness::Little` parse a little endian i64 integer.
1712///
1713/// *Complete version*: returns an error if there is not enough input data
1714///
1715/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1716///
1717/// # Example
1718///
1719/// ```rust
1720/// # use nom8::{Err, error::ErrorKind, Needed};
1721/// # use nom8::Needed::Size;
1722/// use nom8::number::i64;
1723///
1724/// let be_i64 = |s| {
1725///   i64(nom8::number::Endianness::Big)(s)
1726/// };
1727///
1728/// assert_eq!(be_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0001020304050607)));
1729/// assert_eq!(be_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1730///
1731/// let le_i64 = |s| {
1732///   i64(nom8::number::Endianness::Little)(s)
1733/// };
1734///
1735/// assert_eq!(le_i64(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x0706050403020100)));
1736/// assert_eq!(le_i64(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1737/// ```
1738///
1739/// ```rust
1740/// # use nom8::{Err, error::ErrorKind, Needed};
1741/// # use nom8::Needed::Size;
1742/// # use nom8::input::Streaming;
1743/// use nom8::number::i64;
1744///
1745/// let be_i64 = |s| {
1746///   i64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1747/// };
1748///
1749/// assert_eq!(be_i64(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0001020304050607)));
1750/// assert_eq!(be_i64(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
1751///
1752/// let le_i64 = |s| {
1753///   i64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1754/// };
1755///
1756/// assert_eq!(le_i64(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x0706050403020100)));
1757/// assert_eq!(le_i64(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(7))));
1758/// ```
1759#[inline(always)]
1760pub fn i64<I, E: ParseError<I>, const STREAMING: bool>(
1761  endian: crate::number::Endianness,
1762) -> fn(I) -> IResult<I, i64, E>
1763where
1764  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1765{
1766  if STREAMING {
1767    streaming::i64(endian)
1768  } else {
1769    complete::i64(endian)
1770  }
1771}
1772
1773/// Recognizes a signed 16 byte integer
1774///
1775/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian i128 integer,
1776/// otherwise if `nom8::number::Endianness::Little` parse a little endian i128 integer.
1777///
1778/// *Complete version*: returns an error if there is not enough input data
1779///
1780/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1781///
1782/// # Example
1783///
1784/// ```rust
1785/// # use nom8::{Err, error::ErrorKind, Needed};
1786/// # use nom8::Needed::Size;
1787/// use nom8::number::i128;
1788///
1789/// let be_i128 = |s| {
1790///   i128(nom8::number::Endianness::Big)(s)
1791/// };
1792///
1793/// assert_eq!(be_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x00010203040506070001020304050607)));
1794/// assert_eq!(be_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1795///
1796/// let le_i128 = |s| {
1797///   i128(nom8::number::Endianness::Little)(s)
1798/// };
1799///
1800/// assert_eq!(le_i128(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..]), Ok((&b"abcefg"[..], 0x07060504030201000706050403020100)));
1801/// assert_eq!(le_i128(&b"\x01"[..]), Err(Err::Error((&[0x01][..], ErrorKind::Eof))));
1802/// ```
1803///
1804/// ```rust
1805/// # use nom8::{Err, error::ErrorKind, Needed};
1806/// # use nom8::Needed::Size;
1807/// # use nom8::input::Streaming;
1808/// use nom8::number::i128;
1809///
1810/// let be_i128 = |s| {
1811///   i128::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
1812/// };
1813///
1814/// assert_eq!(be_i128(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x00010203040506070001020304050607)));
1815/// assert_eq!(be_i128(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
1816///
1817/// let le_i128 = |s| {
1818///   i128::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
1819/// };
1820///
1821/// assert_eq!(le_i128(Streaming(&b"\x00\x01\x02\x03\x04\x05\x06\x07\x00\x01\x02\x03\x04\x05\x06\x07abcefg"[..])), Ok((Streaming(&b"abcefg"[..]), 0x07060504030201000706050403020100)));
1822/// assert_eq!(le_i128(Streaming(&b"\x01"[..])), Err(Err::Incomplete(Needed::new(15))));
1823/// ```
1824#[inline(always)]
1825pub fn i128<I, E: ParseError<I>, const STREAMING: bool>(
1826  endian: crate::number::Endianness,
1827) -> fn(I) -> IResult<I, i128, E>
1828where
1829  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1830{
1831  if STREAMING {
1832    streaming::i128(endian)
1833  } else {
1834    complete::i128(endian)
1835  }
1836}
1837
1838/// Recognizes a big endian 4 bytes floating point number.
1839///
1840/// *Complete version*: Returns an error if there is not enough input data.
1841///
1842/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1843///
1844/// # Example
1845///
1846/// ```rust
1847/// # use nom8::{Err, error::ErrorKind, Needed};
1848/// # use nom8::Needed::Size;
1849/// use nom8::number::be_f32;
1850///
1851/// let parser = |s| {
1852///   be_f32(s)
1853/// };
1854///
1855/// assert_eq!(parser(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1856/// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1857/// ```
1858///
1859/// ```rust
1860/// # use nom8::{Err, error::ErrorKind, Needed};
1861/// # use nom8::input::Streaming;
1862/// use nom8::number::be_f32;
1863///
1864/// let parser = |s| {
1865///   be_f32::<_, (_, ErrorKind), true>(s)
1866/// };
1867///
1868/// assert_eq!(parser(Streaming(&[0x40, 0x29, 0x00, 0x00][..])), Ok((Streaming(&b""[..]), 2.640625)));
1869/// assert_eq!(parser(Streaming(&[0x01][..])), Err(Err::Incomplete(Needed::new(3))));
1870/// ```
1871#[inline(always)]
1872pub fn be_f32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, f32, E>
1873where
1874  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1875{
1876  if STREAMING {
1877    streaming::be_f32(input)
1878  } else {
1879    complete::be_f32(input)
1880  }
1881}
1882
1883/// Recognizes a big endian 8 bytes floating point number.
1884///
1885/// *Complete version*: Returns an error if there is not enough input data.
1886///
1887/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1888///
1889/// # Example
1890///
1891/// ```rust
1892/// # use nom8::{Err, error::ErrorKind, Needed};
1893/// # use nom8::Needed::Size;
1894/// use nom8::number::be_f64;
1895///
1896/// let parser = |s| {
1897///   be_f64(s)
1898/// };
1899///
1900/// assert_eq!(parser(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
1901/// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1902/// ```
1903///
1904/// ```rust
1905/// # use nom8::{Err, error::ErrorKind, Needed};
1906/// # use nom8::input::Streaming;
1907/// use nom8::number::be_f64;
1908///
1909/// let parser = |s| {
1910///   be_f64::<_, (_, ErrorKind), true>(s)
1911/// };
1912///
1913/// assert_eq!(parser(Streaming(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Streaming(&b""[..]), 12.5)));
1914/// assert_eq!(parser(Streaming(&[0x01][..])), Err(Err::Incomplete(Needed::new(7))));
1915/// ```
1916#[inline(always)]
1917pub fn be_f64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, f64, E>
1918where
1919  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1920{
1921  if STREAMING {
1922    streaming::be_f64(input)
1923  } else {
1924    complete::be_f64(input)
1925  }
1926}
1927
1928/// Recognizes a little endian 4 bytes floating point number.
1929///
1930/// *Complete version*: Returns an error if there is not enough input data.
1931///
1932/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1933///
1934/// # Example
1935///
1936/// ```rust
1937/// # use nom8::{Err, error::ErrorKind, Needed};
1938/// # use nom8::Needed::Size;
1939/// use nom8::number::le_f32;
1940///
1941/// let parser = |s| {
1942///   le_f32(s)
1943/// };
1944///
1945/// assert_eq!(parser(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
1946/// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1947/// ```
1948///
1949/// ```rust
1950/// # use nom8::{Err, error::ErrorKind, Needed};
1951/// # use nom8::input::Streaming;
1952/// use nom8::number::le_f32;
1953///
1954/// let parser = |s| {
1955///   le_f32::<_, (_, ErrorKind), true>(s)
1956/// };
1957///
1958/// assert_eq!(parser(Streaming(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Streaming(&b""[..]), 12.5)));
1959/// assert_eq!(parser(Streaming(&[0x01][..])), Err(Err::Incomplete(Needed::new(3))));
1960/// ```
1961#[inline(always)]
1962pub fn le_f32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, f32, E>
1963where
1964  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
1965{
1966  if STREAMING {
1967    streaming::le_f32(input)
1968  } else {
1969    complete::le_f32(input)
1970  }
1971}
1972
1973/// Recognizes a little endian 8 bytes floating point number.
1974///
1975/// *Complete version*: Returns an error if there is not enough input data.
1976///
1977/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
1978///
1979/// # Example
1980///
1981/// ```rust
1982/// # use nom8::{Err, error::ErrorKind, Needed};
1983/// # use nom8::Needed::Size;
1984/// use nom8::number::le_f64;
1985///
1986/// let parser = |s| {
1987///   le_f64(s)
1988/// };
1989///
1990/// assert_eq!(parser(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
1991/// assert_eq!(parser(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
1992/// ```
1993///
1994/// ```rust
1995/// # use nom8::{Err, error::ErrorKind, Needed};
1996/// # use nom8::input::Streaming;
1997/// use nom8::number::le_f64;
1998///
1999/// let parser = |s| {
2000///   le_f64::<_, (_, ErrorKind), true>(s)
2001/// };
2002///
2003/// assert_eq!(parser(Streaming(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x48, 0x41][..])), Ok((Streaming(&b""[..]), 3145728.0)));
2004/// assert_eq!(parser(Streaming(&[0x01][..])), Err(Err::Incomplete(Needed::new(7))));
2005/// ```
2006#[inline(always)]
2007pub fn le_f64<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, f64, E>
2008where
2009  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
2010{
2011  if STREAMING {
2012    streaming::le_f64(input)
2013  } else {
2014    complete::le_f64(input)
2015  }
2016}
2017
2018/// Recognizes a 4 byte floating point number
2019///
2020/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian f32 float,
2021/// otherwise if `nom8::number::Endianness::Little` parse a little endian f32 float.
2022///
2023/// *Complete version*: returns an error if there is not enough input data
2024///
2025/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
2026///
2027/// # Example
2028///
2029/// ```rust
2030/// # use nom8::{Err, error::ErrorKind, Needed};
2031/// # use nom8::Needed::Size;
2032/// use nom8::number::f32;
2033///
2034/// let be_f32 = |s| {
2035///   f32(nom8::number::Endianness::Big)(s)
2036/// };
2037///
2038/// assert_eq!(be_f32(&[0x41, 0x48, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
2039/// assert_eq!(be_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
2040///
2041/// let le_f32 = |s| {
2042///   f32(nom8::number::Endianness::Little)(s)
2043/// };
2044///
2045/// assert_eq!(le_f32(&[0x00, 0x00, 0x48, 0x41][..]), Ok((&b""[..], 12.5)));
2046/// assert_eq!(le_f32(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
2047/// ```
2048///
2049/// ```rust
2050/// # use nom8::{Err, error::ErrorKind, Needed};
2051/// # use nom8::Needed::Size;
2052/// # use nom8::input::Streaming;
2053/// use nom8::number::f32;
2054///
2055/// let be_f32 = |s| {
2056///   f32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
2057/// };
2058///
2059/// assert_eq!(be_f32(Streaming(&[0x41, 0x48, 0x00, 0x00][..])), Ok((Streaming(&b""[..]), 12.5)));
2060/// assert_eq!(be_f32(Streaming(&b"abc"[..])), Err(Err::Incomplete(Needed::new(1))));
2061///
2062/// let le_f32 = |s| {
2063///   f32::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
2064/// };
2065///
2066/// assert_eq!(le_f32(Streaming(&[0x00, 0x00, 0x48, 0x41][..])), Ok((Streaming(&b""[..]), 12.5)));
2067/// assert_eq!(le_f32(Streaming(&b"abc"[..])), Err(Err::Incomplete(Needed::new(1))));
2068/// ```
2069#[inline(always)]
2070pub fn f32<I, E: ParseError<I>, const STREAMING: bool>(
2071  endian: crate::number::Endianness,
2072) -> fn(I) -> IResult<I, f32, E>
2073where
2074  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
2075{
2076  if STREAMING {
2077    streaming::f32(endian)
2078  } else {
2079    complete::f32(endian)
2080  }
2081}
2082
2083/// Recognizes an 8 byte floating point number
2084///
2085/// If the parameter is `nom8::number::Endianness::Big`, parse a big endian f64 float,
2086/// otherwise if `nom8::number::Endianness::Little` parse a little endian f64 float.
2087///
2088/// *Complete version*: returns an error if there is not enough input data
2089///
2090/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
2091///
2092/// # Example
2093///
2094/// ```rust
2095/// # use nom8::{Err, error::ErrorKind, Needed};
2096/// # use nom8::Needed::Size;
2097/// use nom8::number::f64;
2098///
2099/// let be_f64 = |s| {
2100///   f64(nom8::number::Endianness::Big)(s)
2101/// };
2102///
2103/// assert_eq!(be_f64(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..]), Ok((&b""[..], 12.5)));
2104/// assert_eq!(be_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
2105///
2106/// let le_f64 = |s| {
2107///   f64(nom8::number::Endianness::Little)(s)
2108/// };
2109///
2110/// assert_eq!(le_f64(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..]), Ok((&b""[..], 12.5)));
2111/// assert_eq!(le_f64(&b"abc"[..]), Err(Err::Error((&b"abc"[..], ErrorKind::Eof))));
2112/// ```
2113///
2114/// ```rust
2115/// # use nom8::{Err, error::ErrorKind, Needed};
2116/// # use nom8::Needed::Size;
2117/// # use nom8::input::Streaming;
2118/// use nom8::number::f64;
2119///
2120/// let be_f64 = |s| {
2121///   f64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Big)(s)
2122/// };
2123///
2124/// assert_eq!(be_f64(Streaming(&[0x40, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00][..])), Ok((Streaming(&b""[..]), 12.5)));
2125/// assert_eq!(be_f64(Streaming(&b"abc"[..])), Err(Err::Incomplete(Needed::new(5))));
2126///
2127/// let le_f64 = |s| {
2128///   f64::<_, (_, ErrorKind), true>(nom8::number::Endianness::Little)(s)
2129/// };
2130///
2131/// assert_eq!(le_f64(Streaming(&[0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x40][..])), Ok((Streaming(&b""[..]), 12.5)));
2132/// assert_eq!(le_f64(Streaming(&b"abc"[..])), Err(Err::Incomplete(Needed::new(5))));
2133/// ```
2134#[inline(always)]
2135pub fn f64<I, E: ParseError<I>, const STREAMING: bool>(
2136  endian: crate::number::Endianness,
2137) -> fn(I) -> IResult<I, f64, E>
2138where
2139  I: Slice<RangeFrom<usize>> + InputIter<Item = u8> + InputLength + InputIsStreaming<STREAMING>,
2140{
2141  if STREAMING {
2142    streaming::f64(endian)
2143  } else {
2144    complete::f64(endian)
2145  }
2146}
2147
2148/// Recognizes a hex-encoded integer.
2149///
2150/// *Complete version*: Will parse until the end of input if it has less than 8 bytes.
2151///
2152/// *Streaming version*: Will return `Err(nom8::Err::Incomplete(_))` if there is not enough data.
2153///
2154/// # Example
2155///
2156/// ```rust
2157/// # use nom8::{Err, error::ErrorKind, Needed};
2158/// # use nom8::Needed::Size;
2159/// use nom8::number::hex_u32;
2160///
2161/// let parser = |s| {
2162///   hex_u32(s)
2163/// };
2164///
2165/// assert_eq!(parser(&b"01AE"[..]), Ok((&b""[..], 0x01AE)));
2166/// assert_eq!(parser(&b"abc"[..]), Ok((&b""[..], 0x0ABC)));
2167/// assert_eq!(parser(&b"ggg"[..]), Err(Err::Error((&b"ggg"[..], ErrorKind::IsA))));
2168/// ```
2169///
2170/// ```rust
2171/// # use nom8::{Err, error::ErrorKind, Needed};
2172/// # use nom8::input::Streaming;
2173/// use nom8::number::hex_u32;
2174///
2175/// let parser = |s| {
2176///   hex_u32(s)
2177/// };
2178///
2179/// assert_eq!(parser(Streaming(&b"01AE;"[..])), Ok((Streaming(&b";"[..]), 0x01AE)));
2180/// assert_eq!(parser(Streaming(&b"abc"[..])), Err(Err::Incomplete(Needed::new(1))));
2181/// assert_eq!(parser(Streaming(&b"ggg"[..])), Err(Err::Error((Streaming(&b"ggg"[..]), ErrorKind::IsA))));
2182/// ```
2183#[inline(always)]
2184pub fn hex_u32<I, E: ParseError<I>, const STREAMING: bool>(input: I) -> IResult<I, u32, E>
2185where
2186  I: InputTakeAtPosition + InputIsStreaming<STREAMING>,
2187  I: Slice<RangeFrom<usize>> + Slice<RangeTo<usize>>,
2188  <I as InputTakeAtPosition>::Item: AsChar,
2189  I: AsBytes,
2190  I: InputLength,
2191{
2192  if STREAMING {
2193    streaming::hex_u32(input)
2194  } else {
2195    complete::hex_u32(input)
2196  }
2197}
nom8/number/mod.rs

nom8/number/
mod.rs
