ecitygml-core 0.0.2-alpha.3

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

use crate::model::building::Building;
use crate::model::city_furniture::CityFurniture;
use crate::model::common::{FeatureRef, FeatureType};
use crate::model::core::{
    AbstractCityObject, AbstractFeature, AbstractFeatureWithLifespan, AsAbstractCityObject,
    AsAbstractFeature, AsAbstractFeatureWithLifespan,
};
use crate::model::relief::ReliefFeature;
use crate::model::transportation::Road;
use crate::model::vegetation::SolitaryVegetationObject;

/// A reference to a city object that appears directly in a [`crate::model::core::CityModel`],
/// i.e. a top-level member rather than a child of another object.
#[derive(Debug, Clone, Copy)]
pub enum TopLevelFeatureRef<'a> {
    Building(&'a Building),
    CityFurniture(&'a CityFurniture),
    ReliefFeature(&'a ReliefFeature),
    Road(&'a Road),
    SolitaryVegetationObject(&'a SolitaryVegetationObject),
}

impl<'a> TopLevelFeatureRef<'a> {
    pub fn feature_type(&self) -> FeatureType {
        match self {
            TopLevelFeatureRef::Building(_) => FeatureType::Building,
            TopLevelFeatureRef::CityFurniture(_) => FeatureType::CityFurniture,
            TopLevelFeatureRef::ReliefFeature(_) => FeatureType::ReliefFeature,
            TopLevelFeatureRef::Road(_) => FeatureType::Road,
            TopLevelFeatureRef::SolitaryVegetationObject(_) => {
                FeatureType::SolitaryVegetationObject
            }
        }
    }
}

impl<'a> AsAbstractCityObject for TopLevelFeatureRef<'a> {
    fn abstract_city_object(&self) -> &AbstractCityObject {
        match self {
            TopLevelFeatureRef::Building(x) => x.abstract_city_object(),
            TopLevelFeatureRef::CityFurniture(x) => x.abstract_city_object(),
            TopLevelFeatureRef::ReliefFeature(x) => x.abstract_city_object(),
            TopLevelFeatureRef::Road(x) => x.abstract_city_object(),
            TopLevelFeatureRef::SolitaryVegetationObject(x) => x.abstract_city_object(),
        }
    }
}

impl<'a> AsAbstractFeatureWithLifespan for TopLevelFeatureRef<'a> {
    fn abstract_feature_with_lifespan(&self) -> &AbstractFeatureWithLifespan {
        match self {
            TopLevelFeatureRef::Building(x) => x.abstract_feature_with_lifespan(),
            TopLevelFeatureRef::CityFurniture(x) => x.abstract_feature_with_lifespan(),
            TopLevelFeatureRef::ReliefFeature(x) => x.abstract_feature_with_lifespan(),
            TopLevelFeatureRef::Road(x) => x.abstract_feature_with_lifespan(),
            TopLevelFeatureRef::SolitaryVegetationObject(x) => x.abstract_feature_with_lifespan(),
        }
    }
}

impl<'a> AsAbstractFeature for TopLevelFeatureRef<'a> {
    fn abstract_feature(&self) -> &AbstractFeature {
        match self {
            TopLevelFeatureRef::Building(x) => x.abstract_feature(),
            TopLevelFeatureRef::CityFurniture(x) => x.abstract_feature(),
            TopLevelFeatureRef::ReliefFeature(x) => x.abstract_feature(),
            TopLevelFeatureRef::Road(x) => x.abstract_feature(),
            TopLevelFeatureRef::SolitaryVegetationObject(x) => x.abstract_feature(),
        }
    }
}

impl<'a> From<TopLevelFeatureRef<'a>> for FeatureRef<'a> {
    fn from(value: TopLevelFeatureRef<'a>) -> Self {
        match value {
            TopLevelFeatureRef::Building(x) => Self::Building(x),
            TopLevelFeatureRef::CityFurniture(x) => Self::CityFurniture(x),
            TopLevelFeatureRef::ReliefFeature(x) => Self::ReliefFeature(x),
            TopLevelFeatureRef::Road(x) => Self::Road(x),
            TopLevelFeatureRef::SolitaryVegetationObject(x) => Self::SolitaryVegetationObject(x),
        }
    }
}