ecitygml-io 0.0.2-alpha.5

IO operations for processing CityGML 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
115
116
117
118
119
120

use crate::Error;
use crate::gml::codec::vegetation::abstract_vegetation_object::{
    deserialize_abstract_vegetation_object, serialize_abstract_vegetation_object,
};
use crate::gml::util::CityGmlElement;
use ecitygml_core::model::vegetation::values::{
    PlantCoverClassValue, PlantCoverFunctionValue, PlantCoverUsageValue,
};
use ecitygml_core::model::vegetation::{AsAbstractVegetationObject, PlantCover};
use egml::io::codec::basic::{GmlCode, GmlMeasure};
use egml::io::util::{
    Formatting, XmlNode, XmlNodeContent, extract_xml_element_spans, serialize_inner,
};
use egml::model::basic_types::Code;
use quick_xml::de;
use serde::{Deserialize, Serialize};

pub fn deserialize_plant_cover(xml_document: &[u8]) -> Result<PlantCover, Error> {
    let spans = extract_xml_element_spans(xml_document)?;
    let (abstract_vegetation_object_result, parsed_result) = rayon::join(
        || deserialize_abstract_vegetation_object(xml_document, &spans),
        || de::from_reader::<_, GmlPlantCover>(xml_document).map_err(Error::from),
    );
    let abstract_vegetation_object = abstract_vegetation_object_result?;
    let parsed = parsed_result?;
    let mut plant_cover = PlantCover::from_abstract_vegetation_object(abstract_vegetation_object);

    plant_cover.set_class_opt(parsed.class.map(Code::from).map(PlantCoverClassValue::from));
    plant_cover.set_functions(
        parsed
            .functions
            .into_iter()
            .map(Code::from)
            .map(PlantCoverFunctionValue::from)
            .collect(),
    );
    plant_cover.set_usages(
        parsed
            .usages
            .into_iter()
            .map(Code::from)
            .map(PlantCoverUsageValue::from)
            .collect(),
    );
    plant_cover.set_average_height_opt(parsed.average_height.map(Into::into));
    plant_cover.set_min_height_opt(parsed.min_height.map(Into::into));
    plant_cover.set_max_height_opt(parsed.max_height.map(Into::into));

    Ok(plant_cover)
}

pub fn serialize_plant_cover(
    plant_cover: &PlantCover,
    formatting: Formatting,
) -> Result<XmlNode, Error> {
    let mut parts =
        serialize_abstract_vegetation_object(plant_cover.abstract_vegetation_object(), formatting)?;

    if let Some(raw) = serialize_inner(GmlPlantCover::from(plant_cover), formatting)? {
        parts.content.push(XmlNodeContent::Raw(raw));
    }

    Ok(XmlNode::new(CityGmlElement::PlantCover.into(), parts))
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub struct GmlPlantCover {
    #[serde(
        rename(serialize = "veg:class", deserialize = "class"),
        skip_serializing_if = "Option::is_none"
    )]
    pub class: Option<GmlCode>,

    #[serde(rename(serialize = "veg:function", deserialize = "function"), default)]
    pub functions: Vec<GmlCode>,

    #[serde(rename(serialize = "veg:usage", deserialize = "usage"), default)]
    pub usages: Vec<GmlCode>,

    #[serde(
        rename(serialize = "veg:averageHeight", deserialize = "averageHeight"),
        skip_serializing_if = "Option::is_none"
    )]
    pub average_height: Option<GmlMeasure>,

    #[serde(
        rename(serialize = "veg:minHeight", deserialize = "minHeight"),
        skip_serializing_if = "Option::is_none"
    )]
    pub min_height: Option<GmlMeasure>,

    #[serde(
        rename(serialize = "veg:maxHeight", deserialize = "maxHeight"),
        skip_serializing_if = "Option::is_none"
    )]
    pub max_height: Option<GmlMeasure>,
}

impl From<&PlantCover> for GmlPlantCover {
    fn from(item: &PlantCover) -> Self {
        Self {
            class: item.class().map(PlantCoverClassValue::code).map(Into::into),
            functions: item
                .functions()
                .iter()
                .map(PlantCoverFunctionValue::code)
                .map(Into::into)
                .collect(),
            usages: item
                .usages()
                .iter()
                .map(PlantCoverUsageValue::code)
                .map(Into::into)
                .collect(),
            average_height: item.average_height().map(Into::into),
            min_height: item.min_height().map(Into::into),
            max_height: item.max_height().map(Into::into),
        }
    }
}