xot 0.31.2

Full-featured XML tree library for Rust
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

use crate::xmlvalue::{Attribute, Value, ValueCategory};
use crate::{NameId, Node, Xot};

use super::core::{category_predicate, MutableNodeMap, NodeMap, ValueAdapter};

pub struct AttributeAdapter {}

impl ValueAdapter<NameId, String> for AttributeAdapter {
    fn matches(value: &Value) -> bool {
        matches!(value, Value::Attribute(_))
    }

    fn children(xot: &Xot, node: Node) -> impl Iterator<Item = Node> + '_ {
        xot.all_children(node)
            .skip_while(category_predicate(xot, ValueCategory::Namespace))
            .take_while(category_predicate(xot, ValueCategory::Attribute))
    }

    fn insertion_point(xot: &Xot, node: Node) -> Option<Node> {
        let last_child = Self::children(xot, node).last();
        // if there is a last child, insert after it
        if let Some(last_child) = last_child {
            return Some(last_child);
        }
        // if there is no last child, then insert after the last namespace node
        let namespaces = xot
            .all_children(node)
            .take_while(category_predicate(xot, ValueCategory::Namespace));
        if let Some(last_namespace) = namespaces.last() {
            return Some(last_namespace);
        }
        // if there is no namespace node, we want to prepend
        None
    }

    fn key(value: &Value) -> NameId {
        match value {
            Value::Attribute(Attribute { name_id, .. }) => *name_id,
            _ => unreachable!(),
        }
    }

    fn value(value: &Value) -> &String {
        match value {
            Value::Attribute(Attribute { value, .. }) => value,
            _ => unreachable!(),
        }
    }

    fn value_mut(value: &mut Value) -> &mut String {
        match value {
            Value::Attribute(Attribute { value, .. }) => value,
            _ => unreachable!(),
        }
    }

    fn create(key: NameId, value: String) -> Value {
        Value::Attribute(Attribute {
            name_id: key,
            value,
        })
    }

    fn update(value: &mut Value, new_value: String) -> Option<String> {
        match value {
            Value::Attribute(Attribute {
                value: old_value, ..
            }) => {
                let old_value = std::mem::replace(old_value, new_value);
                Some(old_value)
            }
            _ => unreachable!(),
        }
    }
}

/// Attributes of an element.
///
/// Behaves like a HashMap, but stores the data in the tree, so that namespace
/// nodes have a parent and can exist unattached.
///
/// Access is linear time. Insertion order is preserved.
///
/// Obtained using [`Xot::attributes`].
///
/// See [`NodeMap`] for details.
pub type Attributes<'a> = NodeMap<'a, NameId, String, AttributeAdapter>;

/// Mutable attributes of an element.
///
/// Obtained using [`Xot::attributes_mut`].
///
/// See [`MutableNodeMap`] for details.
///
/// See also [`Attributes`].
pub type MutableAttributes<'a> = MutableNodeMap<'a, NameId, String, AttributeAdapter>;