ajson 0.3.1

JSON Parser for Rust - Get JSON values quickly
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

use super::{query::Query, sub_selector::SubSelector, Path};

#[derive(Default)]
pub struct Builder<'a> {
    ok:        Option<bool>,
    ident:     Option<&'a [u8]>,
    next:      Option<&'a [u8]>,
    more:      Option<bool>,
    #[cfg(feature = "wild")]
    wild:      Option<bool>,
    arrch:     Option<bool>,
    query:     Option<Query<'a>>,
    selectors: Option<Vec<SubSelector<'a>>>,
    arrsel:    Option<bool>,
    esc:       Option<bool>,
}

impl<'a> Builder<'a> {
    pub fn build(self) -> crate::Result<Path<'a>> {
        Ok(Path {
            ok: self.ok.unwrap_or_default(),
            part: self.ident.unwrap_or_default(),
            next: self.next.unwrap_or_default(),
            query: self.query,
            selectors: self.selectors,
            arrsel: self.arrsel.unwrap_or_default(),
            more: self.more.unwrap_or_default(),
            #[cfg(feature = "wild")]
            wild: self.wild.unwrap_or_default(),
            arrch: self.arrch.unwrap_or_default(),
            esc: self.esc.unwrap_or_default(),
        })
    }
}

impl<'a> Builder<'a> {
    pub fn ident(mut self, ident: &'a [u8]) -> Self {
        self.ident = Some(ident);
        self
    }

    pub fn more(mut self, more: bool) -> Self {
        self.more = Some(more);
        self
    }

    pub fn next(mut self, next: &'a [u8]) -> Self {
        self.next = Some(next);
        self
    }

    #[cfg(feature = "wild")]
    pub fn wild(mut self, wild: bool) -> Self {
        self.wild = Some(wild);
        self
    }

    pub fn ok(mut self, ok: bool) -> Self {
        self.ok = Some(ok);
        self
    }

    pub fn esc(mut self, esc: bool) -> Self {
        self.esc = Some(esc);
        self
    }

    pub fn arrch(mut self, arrch: bool) -> Self {
        self.arrch = Some(arrch);
        self
    }

    pub fn query(mut self, query: Query<'a>) -> Self {
        self.query = Some(query);
        self
    }

    pub fn selector(mut self, sels: Vec<SubSelector<'a>>) -> Self {
        self.selectors = Some(sels);
        self
    }

    pub fn arrsel(mut self, arrsel: bool) -> Self {
        self.arrsel = Some(arrsel);
        self
    }
}