Skip to main content

ecitygml_core/model/building/
abstract_building_subdivision.rs

1use crate::model::building::{BuildingUnit, Storey};
2use crate::model::core::{AbstractLogicalSpace, AsAbstractLogicalSpace, AsAbstractLogicalSpaceMut};
3
4#[derive(Debug, Clone, PartialEq)]
5pub struct AbstractBuildingSubdivision {
6    pub abstract_logical_space: AbstractLogicalSpace,
7}
8
9impl AbstractBuildingSubdivision {
10    pub fn new(abstract_logical_space: AbstractLogicalSpace) -> Self {
11        Self {
12            abstract_logical_space,
13        }
14    }
15}
16
17pub trait AsAbstractBuildingSubdivision: AsAbstractLogicalSpace {
18    fn abstract_building_subdivision(&self) -> &AbstractBuildingSubdivision;
19}
20
21pub trait AsAbstractBuildingSubdivisionMut:
22    AsAbstractLogicalSpaceMut + AsAbstractBuildingSubdivision
23{
24    fn abstract_building_subdivision_mut(&mut self) -> &mut AbstractBuildingSubdivision;
25}
26
27impl AsAbstractBuildingSubdivision for AbstractBuildingSubdivision {
28    fn abstract_building_subdivision(&self) -> &AbstractBuildingSubdivision {
29        self
30    }
31}
32
33impl AsAbstractBuildingSubdivisionMut for AbstractBuildingSubdivision {
34    fn abstract_building_subdivision_mut(&mut self) -> &mut AbstractBuildingSubdivision {
35        self
36    }
37}
38
39#[macro_export]
40macro_rules! impl_abstract_building_subdivision_traits {
41    ($type:ty) => {
42        $crate::impl_abstract_logical_space_traits!($type);
43
44        impl $crate::model::core::AsAbstractLogicalSpace for $type {
45            fn abstract_logical_space(&self) -> &$crate::model::core::AbstractLogicalSpace {
46                use $crate::model::building::AsAbstractBuildingSubdivision;
47                &self.abstract_building_subdivision().abstract_logical_space
48            }
49        }
50
51        impl $crate::model::core::AsAbstractLogicalSpaceMut for $type {
52            fn abstract_logical_space_mut(
53                &mut self,
54            ) -> &mut $crate::model::core::AbstractLogicalSpace {
55                use $crate::model::building::AsAbstractBuildingSubdivisionMut;
56                &mut self
57                    .abstract_building_subdivision_mut()
58                    .abstract_logical_space
59            }
60        }
61    };
62}
63
64impl_abstract_building_subdivision_traits!(AbstractBuildingSubdivision);
65
66#[derive(Debug, Clone, PartialEq)]
67pub enum BuildingSubdivisionKind {
68    BuildingUnit(BuildingUnit),
69    Storey(Storey),
70}
71
72impl AsAbstractBuildingSubdivision for BuildingSubdivisionKind {
73    fn abstract_building_subdivision(&self) -> &AbstractBuildingSubdivision {
74        match self {
75            BuildingSubdivisionKind::BuildingUnit(subdivision) => {
76                subdivision.abstract_building_subdivision()
77            }
78            BuildingSubdivisionKind::Storey(subdivision) => {
79                subdivision.abstract_building_subdivision()
80            }
81        }
82    }
83}
84
85impl AsAbstractBuildingSubdivisionMut for BuildingSubdivisionKind {
86    fn abstract_building_subdivision_mut(&mut self) -> &mut AbstractBuildingSubdivision {
87        match self {
88            BuildingSubdivisionKind::BuildingUnit(subdivision) => {
89                subdivision.abstract_building_subdivision_mut()
90            }
91            BuildingSubdivisionKind::Storey(subdivision) => {
92                subdivision.abstract_building_subdivision_mut()
93            }
94        }
95    }
96}
97
98impl_abstract_building_subdivision_traits!(BuildingSubdivisionKind);
99
100impl From<BuildingUnit> for BuildingSubdivisionKind {
101    fn from(item: BuildingUnit) -> Self {
102        BuildingSubdivisionKind::BuildingUnit(item)
103    }
104}
105
106impl From<Storey> for BuildingSubdivisionKind {
107    fn from(item: Storey) -> Self {
108        BuildingSubdivisionKind::Storey(item)
109    }
110}