e57 0.11.12

A pure Rust library for reading and writing E57 files with point clouds and related image data.
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

use crate::error::Converter;
use crate::{DateTime, Error, Result, Transform};
use roxmltree::Node;
use std::fmt::Display;
use std::str::FromStr;

pub fn opt_string(parent_node: &Node, tag_name: &str) -> Result<Option<String>> {
    if let Some(tag) = parent_node.children().find(|n| n.has_tag_name(tag_name)) {
        let expected_type = "String";
        if let Some(found_type) = tag.attribute("type") {
            if found_type != expected_type {
                Error::invalid(format!(
                    "Found XML tag '{tag_name}' with type '{found_type}' instead of '{expected_type}'"
                ))?
            }
        } else {
            Error::invalid(format!("XML tag '{tag_name}' has no 'type' attribute"))?
        }
        let text = tag.text().unwrap_or("");
        Ok(Some(text.to_string()))
    } else {
        Ok(None)
    }
}

pub fn req_string(parent_node: &Node, tag_name: &str) -> Result<String> {
    let str = opt_string(parent_node, tag_name)?;
    str.invalid_err(format!("XML tag '{tag_name}' was not found"))
}

fn opt_num<T: FromStr + Sync + Send>(
    parent_node: &Node,
    tag_name: &str,
    expected_type: &str,
) -> Result<Option<T>> {
    if let Some(tag) = parent_node.children().find(|n| n.has_tag_name(tag_name)) {
        if let Some(found_type) = tag.attribute("type") {
            if found_type != expected_type {
                Error::invalid(format!(
                    "Found XML tag '{tag_name}' with type '{found_type}' instead of '{expected_type}'"
                ))?
            }
        } else {
            Error::invalid(format!("XML tag '{tag_name}' has no 'type' attribute"))?
        }
        let text = tag.text().unwrap_or("0");
        if let Ok(parsed) = text.parse::<T>() {
            Ok(Some(parsed))
        } else {
            Error::invalid(format!(
                "Cannot parse value '{text}' of XML tag '{tag_name}' as '{expected_type}'"
            ))?
        }
    } else {
        Ok(None)
    }
}

pub fn opt_f64(parent_node: &Node, tag_name: &str) -> Result<Option<f64>> {
    opt_num(parent_node, tag_name, "Float")
}

pub fn req_f64(parent_node: &Node, tag_name: &str) -> Result<f64> {
    let double = opt_num(parent_node, tag_name, "Float")?;
    double.invalid_err(format!("XML tag '{tag_name}' was not found"))
}

pub fn opt_int<T: FromStr + Sync + Send>(parent_node: &Node, tag_name: &str) -> Result<Option<T>> {
    opt_num(parent_node, tag_name, "Integer")
}

pub fn req_int<T: FromStr + Send + Sync>(parent_node: &Node, tag_name: &str) -> Result<T> {
    let integer = opt_num(parent_node, tag_name, "Integer")?;
    integer.invalid_err(format!("XML tag '{tag_name}' was not found"))
}

pub fn opt_date_time(parent_node: &Node, tag_name: &str) -> Result<Option<DateTime>> {
    if let Some(tag) = parent_node.children().find(|n| n.has_tag_name(tag_name)) {
        let expected_type = "Structure";
        if let Some(found_type) = tag.attribute("type") {
            if found_type != expected_type {
                Error::invalid(format!(
                    "Found XML tag '{tag_name}' with type '{found_type}' instead of '{expected_type}'"
                ))?
            }
        } else {
            Error::invalid(format!("XML tag '{tag_name}' has no 'type' attribute"))?
        }
        DateTime::from_node(&tag)
    } else {
        Ok(None)
    }
}

pub fn opt_transform(parent_node: &Node, tag_name: &str) -> Result<Option<Transform>> {
    let node = parent_node.children().find(|n| n.has_tag_name(tag_name));
    if let Some(node) = node {
        Ok(Some(Transform::from_node(&node)?))
    } else {
        Ok(None)
    }
}

pub fn gen_string<T: Display>(tag_name: &str, value: &T) -> String {
    format!("<{tag_name} type=\"String\"><![CDATA[{value}]]></{tag_name}>\n")
}

pub fn gen_float<T: Display>(tag_name: &str, value: T) -> String {
    format!("<{tag_name} type=\"Float\">{value}</{tag_name}>\n")
}

pub fn gen_int<T: Display>(tag_name: &str, value: T) -> String {
    format!("<{tag_name} type=\"Integer\">{value}</{tag_name}>\n")
}