opcua_types/xml/
mod.rs

1//! Enabled with the "xml" feature.
2//!
3//! Core utilities for working with decoding OPC UA types from NodeSet2 XML files.
4
5mod builtins;
6mod encoding;
7
8pub use crate::{Context, EncodingResult, Error};
9pub use encoding::{XmlDecodable, XmlEncodable, XmlReadExt, XmlType, XmlWriteExt};
10pub use opcua_xml::{XmlStreamReader, XmlStreamWriter};
11
12use std::{
13    io::{Cursor, Read},
14    str::FromStr,
15};
16
17pub use opcua_xml::schema::opc_ua_types::XmlElement;
18use tracing::warn;
19
20use crate::{
21    Array, ByteString, ExpandedNodeId, ExtensionObject, LocalizedText, NodeId, QualifiedName,
22    StatusCode, UninitializedIndex, Variant, VariantScalarTypeId,
23};
24
25impl From<UninitializedIndex> for Error {
26    fn from(value: UninitializedIndex) -> Self {
27        Self::decoding(format!("Uninitialized index {}", value.0))
28    }
29}
30
31fn mk_node_id(node_id: &opc_ua_types::NodeId, ctx: &Context<'_>) -> Result<NodeId, Error> {
32    let Some(idf) = &node_id.identifier else {
33        return Ok(NodeId::null());
34    };
35    let Ok(mut parsed) = NodeId::from_str(idf) else {
36        return Err(Error::decoding(format!("Invalid node ID: {idf}")));
37    };
38    parsed.namespace = ctx.resolve_namespace_index(parsed.namespace)?;
39    Ok(parsed)
40}
41
42use opcua_xml::{
43    events::Event,
44    schema::opc_ua_types::{self, Variant as XmlVariant},
45};
46
47/// Enter the first tag in the stream, returning `true` if a start tag was found.
48pub(crate) fn enter_first_tag(stream: &mut XmlStreamReader<&mut dyn Read>) -> EncodingResult<bool> {
49    loop {
50        match stream.next_event()? {
51            Event::Start(_) => return Ok(true),
52            Event::End(_) | Event::Eof | Event::Empty(_) => {
53                return Ok(false);
54            }
55            _ => (),
56        }
57    }
58}
59
60fn mk_extension_object(
61    val: &opc_ua_types::ExtensionObject,
62    ctx: &Context<'_>,
63) -> EncodingResult<ExtensionObject> {
64    let Some(body) = &val.body else {
65        return Ok(ExtensionObject::null());
66    };
67    let Some(data) = &body.raw else {
68        return Ok(ExtensionObject::null());
69    };
70    let Some(type_id) = &val.type_id else {
71        return Err(Error::decoding("Extension object missing type ID"));
72    };
73    let node_id = mk_node_id(type_id, ctx)?;
74    let mut cursor = Cursor::new(data.as_bytes());
75    let mut stream = XmlStreamReader::new(&mut cursor as &mut dyn Read);
76    // Read the entry tag, as this is how extension objects are parsed
77    enter_first_tag(&mut stream)?;
78    ctx.load_from_xml(&node_id, &mut stream)
79}
80
81impl Variant {
82    /// Create a Variant value from a NodeSet2 variant object.
83    /// Note that this is different from the `FromXml` implementation of `Variant`,
84    /// which accepts an untyped XML node.
85    pub fn from_nodeset(val: &XmlVariant, ctx: &Context<'_>) -> EncodingResult<Variant> {
86        Ok(match val {
87            XmlVariant::Boolean(v) => (*v).into(),
88            XmlVariant::ListOfBoolean(v) => v.into(),
89            XmlVariant::SByte(v) => (*v).into(),
90            XmlVariant::ListOfSByte(v) => v.into(),
91            XmlVariant::Byte(v) => (*v).into(),
92            XmlVariant::ListOfByte(v) => v.into(),
93            XmlVariant::Int16(v) => (*v).into(),
94            XmlVariant::ListOfInt16(v) => v.into(),
95            XmlVariant::UInt16(v) => (*v).into(),
96            XmlVariant::ListOfUInt16(v) => v.into(),
97            XmlVariant::Int32(v) => (*v).into(),
98            XmlVariant::ListOfInt32(v) => v.into(),
99            XmlVariant::UInt32(v) => (*v).into(),
100            XmlVariant::ListOfUInt32(v) => v.into(),
101            XmlVariant::Int64(v) => (*v).into(),
102            XmlVariant::ListOfInt64(v) => v.into(),
103            XmlVariant::UInt64(v) => (*v).into(),
104            XmlVariant::ListOfUInt64(v) => v.into(),
105            XmlVariant::Float(v) => (*v).into(),
106            XmlVariant::ListOfFloat(v) => v.into(),
107            XmlVariant::Double(v) => (*v).into(),
108            XmlVariant::ListOfDouble(v) => v.into(),
109            XmlVariant::String(v) => v.clone().into(),
110            XmlVariant::ListOfString(v) => v.into(),
111            XmlVariant::DateTime(v) => (*v).into(),
112            XmlVariant::ListOfDateTime(v) => v.into(),
113            XmlVariant::Guid(v) => (*v).into(),
114            XmlVariant::ListOfGuid(v) => v.into(),
115            XmlVariant::ByteString(b) => ByteString::from_base64(b.trim())
116                .unwrap_or_else(|| {
117                    warn!("Invalid byte string: {b}");
118                    ByteString::null()
119                })
120                .into(),
121            XmlVariant::ListOfByteString(v) => v
122                .iter()
123                .map(|b| {
124                    ByteString::from_base64(b.trim()).unwrap_or_else(|| {
125                        warn!("Invalid byte string: {b}");
126                        ByteString::null()
127                    })
128                })
129                .collect::<Vec<_>>()
130                .into(),
131            XmlVariant::XmlElement(vec) => Variant::XmlElement(
132                vec.iter()
133                    .map(|v| v.to_string().trim().to_owned())
134                    .collect::<String>()
135                    .into(),
136            ),
137            XmlVariant::ListOfXmlElement(vec) => Variant::Array(Box::new(Array {
138                value_type: VariantScalarTypeId::XmlElement,
139                values: vec
140                    .iter()
141                    .map(|v| {
142                        Variant::XmlElement(
143                            v.iter()
144                                .map(|vv| vv.to_string().trim().to_string())
145                                .collect::<String>()
146                                .into(),
147                        )
148                    })
149                    .collect(),
150                dimensions: None,
151            })),
152            XmlVariant::QualifiedName(q) => QualifiedName::new(
153                ctx.resolve_namespace_index(q.namespace_index.unwrap_or(0))?,
154                q.name.as_deref().unwrap_or("").trim(),
155            )
156            .into(),
157            XmlVariant::ListOfQualifiedName(v) => v
158                .iter()
159                .map(|q| {
160                    Ok(QualifiedName::new(
161                        ctx.resolve_namespace_index(q.namespace_index.unwrap_or(0))?,
162                        q.name.as_deref().unwrap_or("").trim(),
163                    ))
164                })
165                .collect::<Result<Vec<QualifiedName>, Error>>()?
166                .into(),
167            XmlVariant::LocalizedText(l) => LocalizedText::new(
168                l.locale.as_deref().unwrap_or("").trim(),
169                l.text.as_deref().unwrap_or("").trim(),
170            )
171            .into(),
172            XmlVariant::ListOfLocalizedText(v) => v
173                .iter()
174                .map(|l| {
175                    LocalizedText::new(
176                        l.locale.as_deref().unwrap_or("").trim(),
177                        l.text.as_deref().unwrap_or("").trim(),
178                    )
179                })
180                .collect::<Vec<_>>()
181                .into(),
182            XmlVariant::NodeId(node_id) => mk_node_id(node_id, ctx)?.into(),
183            XmlVariant::ListOfNodeId(v) => v
184                .iter()
185                .map(|node_id| mk_node_id(node_id, ctx))
186                .collect::<Result<Vec<_>, _>>()?
187                .into(),
188            XmlVariant::ExpandedNodeId(node_id) => {
189                ExpandedNodeId::new(mk_node_id(node_id, ctx)?).into()
190            }
191            XmlVariant::ListOfExpandedNodeId(v) => v
192                .iter()
193                .map(|node_id| Ok(ExpandedNodeId::new(mk_node_id(node_id, ctx)?)))
194                .collect::<Result<Vec<_>, Error>>()?
195                .into(),
196            XmlVariant::ExtensionObject(val) => mk_extension_object(val, ctx)?.into(),
197            XmlVariant::ListOfExtensionObject(v) => v
198                .iter()
199                .map(|val| mk_extension_object(val, ctx))
200                .collect::<Result<Vec<_>, _>>()?
201                .into(),
202            XmlVariant::Variant(variant) => {
203                let inner = Variant::from_nodeset(variant, ctx)?;
204                Variant::Variant(Box::new(inner))
205            }
206            XmlVariant::ListOfVariant(vec) => Variant::Array(Box::new(Array {
207                value_type: VariantScalarTypeId::Variant,
208                values: vec
209                    .iter()
210                    .map(|v| Ok(Variant::Variant(Box::new(Variant::from_nodeset(v, ctx)?))))
211                    .collect::<Result<Vec<_>, Error>>()?,
212                dimensions: None,
213            })),
214            XmlVariant::StatusCode(status_code) => StatusCode::from(status_code.code).into(),
215            XmlVariant::ListOfStatusCode(vec) => vec
216                .iter()
217                .map(|v| StatusCode::from(v.code))
218                .collect::<Vec<_>>()
219                .into(),
220        })
221    }
222}
opcua_types/xml/mod.rs

opcua_types/xml/
mod.rs
