use super::attr_f64;
use crate::header::License;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AdditionalData {
pub path: String,
pub road_id: String,
pub data: Additional,
}
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[non_exhaustive]
pub enum Additional {
UserData {
code: String,
value: String,
},
DataQuality(DataQuality),
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DataQuality {
pub error: Option<DataError>,
pub raw_data: Option<RawData>,
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DataError {
pub xy_absolute: Option<f64>,
pub xy_relative: Option<f64>,
pub z_absolute: Option<f64>,
pub z_relative: Option<f64>,
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RawData {
pub date: String,
pub source: String,
pub source_comment: String,
pub post_processing: String,
pub post_processing_comment: String,
}
pub(super) fn collect(root: roxmltree::Node) -> Vec<AdditionalData> {
let mut out = Vec::new();
let text = |n: roxmltree::Node, name| n.attribute(name).unwrap_or_default().to_string();
let inside_user_data =
|n: &roxmltree::Node| n.ancestors().skip(1).any(|a| a.has_tag_name("userData"));
for node in root
.descendants()
.filter(|n| n.is_element() && !inside_user_data(n))
{
let data = if node.has_tag_name("userData") {
Additional::UserData {
code: text(node, "code"),
value: text(node, "value"),
}
} else if node.has_tag_name("dataQuality") {
Additional::DataQuality(data_quality(node))
} else {
continue;
};
let Some(owner) = node.parent_element() else {
continue;
};
let road_id = owner
.ancestors()
.find(|a| a.has_tag_name("road"))
.map_or_else(String::new, |r| text(r, "id"));
out.push(AdditionalData {
path: path(root, owner),
road_id,
data,
});
}
out
}
fn data_quality(node: roxmltree::Node) -> DataQuality {
let child = |tag| node.children().find(|n| n.has_tag_name(tag));
let text = |n: roxmltree::Node, name| n.attribute(name).unwrap_or_default().to_string();
DataQuality {
error: child("error").map(|e| DataError {
xy_absolute: attr_f64(e, "xyAbsolute"),
xy_relative: attr_f64(e, "xyRelative"),
z_absolute: attr_f64(e, "zAbsolute"),
z_relative: attr_f64(e, "zRelative"),
}),
raw_data: child("rawData").map(|r| RawData {
date: text(r, "date"),
source: text(r, "source"),
source_comment: text(r, "sourceComment"),
post_processing: text(r, "postProcessing"),
post_processing_comment: text(r, "postProcessingComment"),
}),
}
}
fn path(root: roxmltree::Node, node: roxmltree::Node) -> String {
let mut steps: Vec<String> = node
.ancestors()
.take_while(|a| *a != root)
.filter(|a| a.is_element())
.map(|a| {
let name = a.tag_name().name();
if let Some(id) = a.attribute("id") {
return format!("{name}[{id}]");
}
let parent = a.parent_element();
let same = |n: &roxmltree::Node| n.is_element() && n.tag_name().name() == name;
let siblings = parent.map_or(1, |p| p.children().filter(same).count());
match siblings > 1 {
true => {
let place = a.prev_siblings().filter(same).count() - 1;
format!("{name}[{place}]")
}
false => name.to_string(),
}
})
.collect();
steps.reverse();
steps.join("/")
}
pub(super) fn license(header: roxmltree::Node) -> Option<License> {
let node = header.children().find(|n| n.has_tag_name("license"))?;
let text = |name| node.attribute(name).unwrap_or_default().to_string();
Some(License {
name: text("name"),
resource: text("resource"),
spdx_id: text("spdxid"),
text: text("text"),
})
}