binator 0.3.0

Parser Combinator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use crate::{
  base::{
    take,
    BaseAtom,
  },
  utils::{
    Utils,
    UtilsAtom,
  },
  Contexting,
  CoreAtom,
  Parse,
  Parsed,
  Streaming,
};

/// Take a &'static str and return a Parser that will
/// compare it with Stream, this requiere the Stream Span
/// to implement `AsRef<[u8]>`
pub fn tag<Stream, Context>(tag: &'static str) -> impl Parse<Stream, Context, Token = &'static str>
where
  Stream: Streaming,
  Stream::Span: AsRef<[u8]>,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Context: Contexting<UtilsAtom<Stream>>,
{
  Tag { tag }
}

struct Tag {
  tag: &'static str,
}

impl<Stream, Context> Parse<Stream, Context> for Tag
where
  Stream: Streaming,
  Stream::Span: AsRef<[u8]>,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Context: Contexting<UtilsAtom<Stream>>,
{
  type Token = &'static str;

  #[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "trace", name = "tag", skip_all, ret(Display))
  )]
  fn parse(&mut self, stream: Stream) -> Parsed<&'static str, Stream, Context> {
    take(self.tag.len())
      .add_atom(|| BaseAtom::Tag { tag: self.tag })
      .try_map(|token: Stream::Span| {
        if token.as_ref() == self.tag.as_bytes() {
          Ok(self.tag)
        } else {
          Err(Context::new(BaseAtom::Tag { tag: self.tag }))
        }
      })
      .parse(stream)
  }
}

/// Take a &'static str and return a Parser that will
/// compare it without the ascii case with Stream, this requiere the Stream Span
/// to implement `AsRef<[u8]>`
pub fn tag_no_case<Stream, Context>(
  tag: &'static str,
) -> impl Parse<Stream, Context, Token = &'static str>
where
  Stream: Streaming,
  Stream::Span: AsRef<[u8]>,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Context: Contexting<UtilsAtom<Stream>>,
{
  TagNoCase { tag }
}

struct TagNoCase {
  tag: &'static str,
}

impl<Stream, Context> Parse<Stream, Context> for TagNoCase
where
  Stream: Streaming,
  Stream::Span: AsRef<[u8]>,
  Context: Contexting<CoreAtom<Stream>>,
  Context: Contexting<BaseAtom<u8>>,
  Context: Contexting<UtilsAtom<Stream>>,
{
  type Token = &'static str;

  #[cfg_attr(
    feature = "tracing",
    tracing::instrument(level = "trace", name = "tag_no_case", skip_all, ret(Display))
  )]
  fn parse(&mut self, stream: Stream) -> Parsed<&'static str, Stream, Context> {
    take(self.tag.len())
      .add_atom(|| BaseAtom::Tag { tag: self.tag })
      .try_map(|token: Stream::Span| {
        if token.as_ref().eq_ignore_ascii_case(self.tag.as_bytes()) {
          Ok(self.tag)
        } else {
          Err(Context::new(BaseAtom::Tag { tag: self.tag }))
        }
      })
      .parse(stream)
  }
}