Skip to main content

rubo4e/generated/v202607/
geraet.rs

1use super::{Bo4eObject, BoTyp, Geraeteklasse, Geraetetyp, ZusatzAttribut};
2#[derive(Debug, Clone, PartialEq)]
3#[cfg_attr(not(feature = "json"), derive(Eq, Hash))]
4#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
5#[cfg_attr(feature = "builder", derive(typed_builder::TypedBuilder))]
6#[cfg_attr(feature = "validate", derive(garde::Validate))]
7#[cfg_attr(feature = "validate", garde(allow_unvalidated))]
8#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
9#[cfg_attr(feature = "utoipa", derive(utoipa::ToSchema))]
10/// Mit diesem BO werden alle Geräte modelliert, die keine Zähler sind.
11///
12/// > **Note:** [Geraet JSON Schema](https://json-schema.app/view/%23?url=https://raw.githubusercontent.com/BO4E/BO4E-Schemas/v202607.1.0/src/bo4e_schemas/bo/Geraet.json)
13pub struct Geraet {
14    /// Bezeichnung des Geräts
15    #[cfg_attr(feature = "serde", serde(rename = "bezeichnung"))]
16    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
17    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
18    pub bezeichnung: Option<String>,
19    /// Die übergreifende Klasse eines Geräts, beispielsweise Wandler
20    #[cfg_attr(feature = "serde", serde(rename = "geraeteklasse"))]
21    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
22    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
23    pub geraeteklasse: Option<Geraeteklasse>,
24    /// Die auf dem Gerät aufgedruckte Nummer, die vom MSB vergeben wird.
25    #[cfg_attr(feature = "serde", serde(rename = "geraetenummer"))]
26    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
27    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
28    pub geraetenummer: Option<String>,
29    /// Der speziellere Typ eines Gerätes, beispielsweise Stromwandler
30    #[cfg_attr(feature = "serde", serde(rename = "geraetetyp"))]
31    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
32    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
33    pub geraetetyp: Option<Geraetetyp>,
34    /// Eine generische ID, die für eigene Zwecke genutzt werden kann.
35    /// Z.B. könnten hier UUIDs aus einer Datenbank stehen oder URLs zu einem Backend-System.
36    #[cfg_attr(feature = "serde", serde(rename = "_id"))]
37    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
38    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
39    pub id: Option<String>,
40    /// BO4E type discriminant — always `BoTyp::Geraet` for this struct.
41    #[cfg_attr(feature = "serde", serde(rename = "_typ"))]
42    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
43    #[cfg_attr(
44        feature = "builder",
45        builder(default = Some(BoTyp::Geraet), setter(skip))
46    )]
47    pub typ: Option<BoTyp>,
48    /// Version der BO-Struktur aka "fachliche Versionierung"
49    #[cfg_attr(feature = "serde", serde(rename = "_version"))]
50    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
51    #[cfg_attr(
52        feature = "builder",
53        builder(default = Some("202607.1.0".to_owned()), setter(into))
54    )]
55    pub version: Option<String>,
56    #[cfg_attr(feature = "serde", serde(rename = "zusatzAttribute"))]
57    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "Option::is_none"))]
58    #[cfg_attr(feature = "builder", builder(default, setter(into)))]
59    pub zusatz_attribute: Option<Vec<ZusatzAttribut>>,
60    /// Unknown JSON fields captured during deserialization for round-trip preservation.
61    /// `None` when no unknown fields were present (zero heap allocation).
62    #[cfg_attr(feature = "json", serde(flatten))]
63    #[cfg_attr(
64        feature = "json",
65        serde(skip_serializing_if = "crate::json::ext_map_is_empty")
66    )]
67    #[cfg_attr(not(feature = "json"), serde(skip))]
68    #[cfg_attr(feature = "builder", builder(default, setter(skip)))]
69    #[doc(hidden)]
70    pub _additional: crate::LimitedExtensionMap,
71}
72impl Default for Geraet {
73    fn default() -> Self {
74        Self {
75            bezeichnung: Default::default(),
76            geraeteklasse: Default::default(),
77            geraetenummer: Default::default(),
78            geraetetyp: Default::default(),
79            id: Default::default(),
80            typ: Some(BoTyp::Geraet),
81            version: Some("202607.1.0".to_owned()),
82            zusatz_attribute: Default::default(),
83            _additional: Default::default(),
84        }
85    }
86}
87impl Bo4eObject for Geraet {
88    type BoTyp = BoTyp;
89    fn bo_type(&self) -> BoTyp {
90        self.typ.unwrap_or(BoTyp::Geraet)
91    }
92    fn schema_version(&self) -> &'static str {
93        "202607.1.0"
94    }
95    fn schema_series(&self) -> &'static str {
96        "202607"
97    }
98}
99#[cfg(feature = "json")]
100impl crate::json::sealed::Sealed for Geraet {}
101#[cfg(feature = "json")]
102impl crate::json::Bo4eJsonExt for Geraet {}
103#[cfg(feature = "json")]
104impl crate::json::Bo4eExtensionData for Geraet {
105    fn extension_data(&self) -> &indexmap::IndexMap<String, serde_json::Value> {
106        self._additional
107            .as_map()
108            .unwrap_or(&crate::json::extension::EMPTY_EXTENSION_MAP)
109    }
110    fn has_extension_data(&self) -> bool {
111        !self._additional.is_empty()
112    }
113}
114#[cfg(feature = "json")]
115impl std::fmt::Display for Geraet {
116    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
117        match serde_json::to_string(self) {
118            Ok(json) => f.write_str(&json),
119            Err(e) => write!(f, "<Geraet: serialization error: {e}>"),
120        }
121    }
122}
123impl crate::Bo4eStrict for Geraet {
124    fn collect_unknown_enums(&self, path: &str, out: &mut Vec<String>) {
125        if let Some(v) = &self.geraeteklasse {
126            crate::Bo4eStrict::collect_unknown_enums(
127                v,
128                &crate::strict::field_path(path, "geraeteklasse"),
129                out,
130            );
131        }
132        if let Some(v) = &self.geraetetyp {
133            crate::Bo4eStrict::collect_unknown_enums(
134                v,
135                &crate::strict::field_path(path, "geraetetyp"),
136                out,
137            );
138        }
139        if let Some(items) = &self.zusatz_attribute {
140            let child = crate::strict::field_path(path, "zusatzAttribute");
141            for (i, item) in items.iter().enumerate() {
142                crate::Bo4eStrict::collect_unknown_enums(
143                    item,
144                    &crate::strict::index_path(&child, i),
145                    out,
146                );
147            }
148        }
149    }
150}