notedown_ast 0.12.9

notedown ast and converter
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

use super::*;

pub trait Index<I> {
    type Output;
    fn get_index(&self, index: &I) -> Self::Output;
}

impl Index<BigInt> for Value {
    type Output = Result<Self>;

    fn get_index(&self, index: &BigInt) -> Self::Output {
        match self {
            Self::Null | Self::Boolean(_) | Self::Integer(_) | Self::Decimal(_) => {
                Err(NoteError::type_mismatch(format!("Can not take `Integer` index of type `{}`", self.get_type_name())))
            }
            Self::String(s) => {
                let i = if index.is_negative() {
                    match index.neg().to_usize() {
                        Some(u) => {
                            let max = s.chars().count();
                            // (u <= max).then_some(max);
                            if u <= max { Some(max) } else { None }
                        }
                        None => None,
                    }
                }
                else {
                    index.to_usize()
                };

                match i.and_then(|e| s.chars().nth(e)) {
                    Some(s) => Ok(Value::string(s)),
                    None => Err(NoteError::runtime_error(format!("Index `{}` of `String` out of range.", index))),
                }
            }
            Self::Set(v) => {
                // let v : BTreeSet<Literal<Value>>;
                let out = if index.is_negative() {
                    index.neg().to_usize().and_then(|i| v.iter().rev().nth(i))
                }
                else {
                    index.to_usize().and_then(|i| v.iter().nth(i))
                };
                match out {
                    Some(s) => Ok(s.value.to_owned()),
                    None => Err(NoteError::runtime_error(format!("Index `{}` of `Set` out of range.", index))),
                }
            }
            Self::Array(v) => {
                let out = if index.is_negative() {
                    // v.last_key_value()
                    // let max = v.keys().next_back();
                    todo!()
                }
                else {
                    index.to_biguint().and_then(|i| v.get(&i))
                };
                match out {
                    Some(s) => Ok(s.value.to_owned()),
                    None => Err(NoteError::runtime_error(format!("Index `{}` of `Array` out of range.", index))),
                }
            }
            Self::Object(v) => {
                // let v : BTreeMap<String, Literal<Value>>;
                let out = if index.is_negative() {
                    index.neg().to_usize().and_then(|i| v.values().rev().nth(i))
                }
                else {
                    index.to_usize().and_then(|i| v.values().nth(i))
                };
                match out {
                    Some(s) => Ok(s.value.to_owned()),
                    None => Err(NoteError::runtime_error(format!("Index `{}` of `Object` out of range.", index))),
                }
            }
        }
    }
}

impl Index<String> for Value {
    type Output = Result<Self>;

    fn get_index(&self, index: &String) -> Self::Output {
        match self {
            Self::Object(v) => {
                // let v : BTreeMap<String, Literal<Value>>;
                match v.get(index) {
                    Some(s) => Ok(s.value.to_owned()),
                    None => Err(NoteError::runtime_error(format!("Index `{}` of `Object` not found.", index))),
                }
            }
            _ => Err(NoteError::type_mismatch(format!("Can not take `String` index of type `{}`", self.get_type_name()))),
        }
    }
}