adf 0.2.0

Minimal-overhead Auto-lead Data Format XML parser and writer
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
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::model::{Adf, Prospect};
use crate::{Result, validate};
use std::borrow::Cow;
use std::io::Write;
use std::ops::Range;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Span {
    pub start: usize,
    pub end: usize,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Attribute<'a> {
    pub name: Cow<'a, str>,
    pub value: Cow<'a, str>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct XmlElement<'a> {
    pub name: Cow<'a, str>,
    pub attributes: Vec<Attribute<'a>>,
    pub children: Vec<XmlNode<'a>>,
    pub span: Span,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum XmlNode<'a> {
    Element(XmlElement<'a>),
    Text(Cow<'a, str>),
    CData(Cow<'a, str>),
    EntityRef(Cow<'a, str>),
    Comment(Cow<'a, str>),
    ProcessingInstruction(Cow<'a, str>),
    Declaration(Cow<'a, str>),
    DocType(Cow<'a, str>),
}

#[derive(Debug, Clone)]
pub struct AdfDocument<'a> {
    pub(crate) original: &'a str,
    pub(crate) root: XmlElement<'a>,
    pub(crate) adf: Adf<'a>,
    pub(crate) prospect_spans: Vec<Range<usize>>,
    pub(crate) dirty_prospects: Vec<bool>,
    pub(crate) dirty_all: bool,
}

impl<'a> AdfDocument<'a> {
    pub(crate) fn new(
        original: &'a str,
        root: XmlElement<'a>,
        adf: Adf<'a>,
        prospect_spans: Vec<Range<usize>>,
    ) -> Self {
        let dirty_prospects = vec![false; prospect_spans.len()];
        Self {
            original,
            root,
            adf,
            prospect_spans,
            dirty_prospects,
            dirty_all: false,
        }
    }

    pub fn original(&self) -> &'a str {
        self.original
    }

    pub fn root(&self) -> &XmlElement<'a> {
        &self.root
    }

    pub fn adf(&self) -> &Adf<'a> {
        &self.adf
    }

    pub fn adf_mut(&mut self) -> &mut Adf<'a> {
        self.dirty_all = true;
        &mut self.adf
    }

    pub fn prospect_mut(&mut self, index: usize) -> Option<&mut Prospect<'a>> {
        if let Some(dirty) = self.dirty_prospects.get_mut(index) {
            *dirty = true;
        }
        self.adf.prospects.get_mut(index)
    }

    pub fn is_dirty(&self) -> bool {
        self.dirty_all || self.dirty_prospects.iter().any(|dirty| *dirty)
    }

    pub fn validate(&self) -> validate::ValidationReport<'a> {
        validate::validate(&self.adf)
    }

    pub fn validate_strict(&self) -> validate::ValidationReport<'a> {
        validate::validate_with(&self.adf, validate::ValidationOptions { strict: true })
    }

    pub fn write_original_preserving<W: Write>(&self, writer: W) -> Result<()> {
        crate::write::write_original_preserving(writer, self)
    }

    pub fn write_typed<W: Write>(&self, writer: W) -> Result<()> {
        crate::write::write_adf(writer, &self.adf)
    }

    pub fn to_original_preserving_string(&self) -> Result<String> {
        let mut bytes = Vec::new();
        self.write_original_preserving(&mut bytes)?;
        Ok(String::from_utf8(bytes).expect("ADF writer only emits UTF-8"))
    }

    pub fn to_typed_string(&self) -> Result<String> {
        let mut bytes = Vec::new();
        self.write_typed(&mut bytes)?;
        Ok(String::from_utf8(bytes).expect("ADF writer only emits UTF-8"))
    }
}