ltk_ritobin 0.12.0

Ritobin text format parser and writer for League Toolkit
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 std::iter::{empty, once};

use crate::ast::{
    node::{
        root::{Root, RootValue},
        MapEntry, NodeRef, SubNodeRef,
    },
    Object, Property, RootEntry, Value,
};

use super::*;

impl<'a> NodeRef<'a> {
    pub fn children(&self) -> Box<dyn Iterator<Item = NodeRef<'a>> + 'a> {
        match self {
            NodeRef::Root(r) => r.children(),
            NodeRef::RootEntry(o) => Box::new(std::iter::once(NodeRef::Object(&o.object))),
            NodeRef::Object(s) => Box::new(s.properties.iter().map(NodeRef::Property)),
            NodeRef::Property(p) => Box::new(p.value.as_ref().map(NodeRef::Value).into_iter()),
            NodeRef::Value(v) => v.children(),
        }
    }
}

impl Root {
    pub fn children<'a>(&'a self) -> Box<dyn Iterator<Item = NodeRef<'a>> + 'a> {
        match &self.value {
            Some(RootValue::Entries(e)) => Box::new(e.iter().map(NodeRef::RootEntry)),
            Some(RootValue::Value(value)) => Box::new(once(NodeRef::Value(value))),
            // roots w/ simple values aren't worth a dedicated node at this resolution
            None => Box::new(empty()),
        }
    }
    pub fn detailed_children<'a>(&'a self) -> impl Iterator<Item = SubNodeRef<'a>> {
        [
            SubNodeRef::Root(self, AstRootDetail::Name),
            SubNodeRef::Root(self, AstRootDetail::TypeExpr),
        ]
        .into_iter()
        .chain(self.children().map(SubNodeRef::from))
        .chain(once(SubNodeRef::Root(self, AstRootDetail::Trivia)))
    }
}

impl RootEntry {
    pub fn children<'a>(&'a self) -> impl Iterator<Item = NodeRef<'a>> {
        once(NodeRef::Object(&self.object))
    }
    pub fn detailed_children<'a>(&'a self) -> impl Iterator<Item = SubNodeRef<'a>> {
        [
            SubNodeRef::RootEntry(self, AstRootEntryDetail::PathHash),
            SubNodeRef::Object(&self.object, AstObjectDetail::Node),
            SubNodeRef::RootEntry(self, AstRootEntryDetail::Trivia),
        ]
        .into_iter()
    }
}

impl Object {
    pub fn children<'a>(&'a self) -> impl Iterator<Item = NodeRef<'a>> {
        self.properties.iter().map(NodeRef::Property)
    }
    pub fn detailed_children<'a>(&'a self) -> impl Iterator<Item = SubNodeRef<'a>> {
        once(SubNodeRef::Object(self, AstObjectDetail::ClassHash))
            .chain(
                self.properties
                    .iter()
                    .map(|v| SubNodeRef::Property(v, AstPropertyDetail::Node)),
            )
            .chain(once(SubNodeRef::Object(self, AstObjectDetail::Trivia)))
    }
}

impl Property {
    pub fn children<'a>(&'a self) -> impl Iterator<Item = NodeRef<'a>> {
        self.value.as_ref().map(NodeRef::Value).into_iter()
    }
    pub fn detailed_children<'a>(&'a self) -> impl Iterator<Item = SubNodeRef<'a>> {
        [
            SubNodeRef::Property(self, AstPropertyDetail::Name),
            SubNodeRef::Property(self, AstPropertyDetail::TypeExpr),
        ]
        .into_iter()
        .chain(self.value.as_ref().map(SubNodeRef::Value))
        .chain(once(SubNodeRef::Property(self, AstPropertyDetail::Trivia)))
    }
}

impl Value {
    pub fn children(&self) -> Box<dyn Iterator<Item = NodeRef<'_>> + '_> {
        match self {
            Value::Struct(s) | Value::Embedded(s) => Box::new(std::iter::once(NodeRef::Object(s))),
            Value::Container { items, .. } | Value::UnorderedContainer { items, .. } => {
                Box::new(items.iter().map(NodeRef::Value))
            }
            Value::Map(map) => Box::new(map.iter().flat_map(
                |MapEntry {
                     key: k, value: v, ..
                 }| {
                    once(NodeRef::Value(k)).chain(v.as_ref().map(NodeRef::Value))
                },
            )),
            Value::Optional {
                value: Some(inner), ..
            } => Box::new(std::iter::once(NodeRef::Value(inner))),
            _ => Box::new(std::iter::empty()),
        }
    }
}