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

use crate::Error;
use crate::gml::codec::transportation::{
    deserialize_intersection, deserialize_railway, deserialize_road, deserialize_section,
    deserialize_square, deserialize_track, deserialize_waterway, serialize_intersection,
    serialize_railway, serialize_road, serialize_section, serialize_square, serialize_track,
    serialize_waterway,
};
use crate::gml::util::{CityGmlElement, CombinedCityGmlElement};
use ecitygml_core::model::transportation::AbstractTransportationSpaceKind;
use egml::io::util::{Formatting, XmlElementSpans, XmlNode};

pub fn deserialize_abstract_transportation_space_kind(
    xml_document: &[u8],
    spans: &XmlElementSpans<CombinedCityGmlElement>,
) -> Result<Option<AbstractTransportationSpaceKind>, Error> {
    if let Some(span) = spans.first(CityGmlElement::Section.into()) {
        let section = deserialize_section(&xml_document[span.start..span.end])?;
        return Ok(Some(section.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Intersection.into()) {
        let intersection = deserialize_intersection(&xml_document[span.start..span.end])?;
        return Ok(Some(intersection.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Road.into()) {
        let road = deserialize_road(&xml_document[span.start..span.end])?;
        return Ok(Some(road.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Track.into()) {
        let track = deserialize_track(&xml_document[span.start..span.end])?;
        return Ok(Some(track.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Railway.into()) {
        let railway = deserialize_railway(&xml_document[span.start..span.end])?;
        return Ok(Some(railway.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Waterway.into()) {
        let waterway = deserialize_waterway(&xml_document[span.start..span.end])?;
        return Ok(Some(waterway.into()));
    }

    if let Some(span) = spans.first(CityGmlElement::Square.into()) {
        let square = deserialize_square(&xml_document[span.start..span.end])?;
        return Ok(Some(square.into()));
    }

    Ok(None)
}

pub fn serialize_abstract_transportation_space_kind(
    abstract_transportation_space_kind: &AbstractTransportationSpaceKind,
    formatting: Formatting,
) -> Result<XmlNode, Error> {
    match abstract_transportation_space_kind {
        AbstractTransportationSpaceKind::Section(x) => serialize_section(x, formatting),
        AbstractTransportationSpaceKind::Intersection(x) => serialize_intersection(x, formatting),
        AbstractTransportationSpaceKind::Road(x) => serialize_road(x, formatting),
        AbstractTransportationSpaceKind::Track(x) => serialize_track(x, formatting),
        AbstractTransportationSpaceKind::Railway(x) => serialize_railway(x, formatting),
        AbstractTransportationSpaceKind::Waterway(x) => serialize_waterway(x, formatting),
        AbstractTransportationSpaceKind::Square(x) => serialize_square(x, formatting),
    }
}