ecitygml-core 0.0.1-alpha.13

Core primitives and 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

use egml::model::base::Id;
use egml::model::geometry::Envelope;

#[derive(Debug, Clone, PartialEq)]
pub struct AbstractFeature {
    pub(crate) abstract_feature: egml::model::feature::AbstractFeature,
}

impl AbstractFeature {
    pub fn new(id: Id) -> Self {
        let abstract_gml = egml::model::base::AbstractGml::with_id(id);
        let abstract_feature = egml::model::feature::AbstractFeature::new(abstract_gml);

        Self { abstract_feature }
    }

    pub fn with_gml_abstract_feature(
        abstract_feature: egml::model::feature::AbstractFeature,
    ) -> Self {
        Self { abstract_feature }
    }

    pub fn id(&self) -> &Id {
        self.abstract_feature
            .abstract_gml
            .id
            .as_ref()
            .expect("id must be set for AbstractFeature")
    }

    pub fn name(&self) -> &Vec<String> {
        &self.abstract_feature.abstract_gml.name
    }

    pub fn set_name(&mut self, name: Vec<String>) {
        self.abstract_feature.abstract_gml.name = name;
    }

    pub fn bounded_by(&self) -> Option<&Envelope> {
        self.abstract_feature.bounded_by.as_ref()
    }

    pub fn set_bounded_by(&mut self, bounded_by: Option<Envelope>) {
        self.abstract_feature.bounded_by = bounded_by;
    }
}

pub trait AsAbstractFeature {
    fn abstract_feature(&self) -> &AbstractFeature;

    fn id(&self) -> &Id {
        self.abstract_feature().id()
    }

    fn name(&self) -> &Vec<String> {
        self.abstract_feature().name()
    }

    fn bounded_by(&self) -> Option<&Envelope> {
        self.abstract_feature().bounded_by()
    }
}

pub trait AsAbstractFeatureMut: AsAbstractFeature {
    fn abstract_feature_mut(&mut self) -> &mut AbstractFeature;

    fn set_name(&mut self, name: Vec<String>) {
        self.abstract_feature_mut().set_name(name);
    }

    fn set_bounded_by(&mut self, envelope: Option<Envelope>) {
        self.abstract_feature_mut().set_bounded_by(envelope);
    }
}

impl AsAbstractFeature for AbstractFeature {
    fn abstract_feature(&self) -> &AbstractFeature {
        self
    }
}

impl AsAbstractFeatureMut for AbstractFeature {
    fn abstract_feature_mut(&mut self) -> &mut AbstractFeature {
        self
    }
}