Handle null values in XML as well

async-opcua-macros/src/encoding/xml.rs

@@ -102,12 +102,16 @@ pub fn generate_xml_encode_impl(strct: EncodingStruct) -> syn::Result<TokenStrea
         if field.attr.optional {
             body.extend(quote! {
                 if let Some(item) = &self.#ident {
-                    stream.encode_child(#name, item, ctx)?;
+                    if !item.is_null_xml() {
+                        stream.encode_child(#name, item, ctx)?;
+                    }
                 }
             });
         } else {
             body.extend(quote! {
-                stream.encode_child(#name, &self.#ident, ctx)?;
+                if !self.#ident.is_null_xml() {
+                    stream.encode_child(#name, &self.#ident, ctx)?;
+                }
             });
         }
     }

async-opcua-types/src/expanded_node_id.rs

@@ -263,6 +263,10 @@ mod xml {
             };
             node_id.encode(writer, context)
         }
+
+        fn is_null_xml(&self) -> bool {
+            self.is_null()
+        }
     }
 
     impl XmlDecodable for ExpandedNodeId {

async-opcua-types/src/node_id.rs

@@ -357,6 +357,10 @@ mod xml {
             let val = ctx.resolve_alias_inverse(&self_str);
             writer.encode_child("Identifier", val, ctx)
         }
+
+        fn is_null_xml(&self) -> bool {
+            self.is_null()
+        }
     }
 
     impl XmlDecodable for NodeId {

async-opcua-types/src/qualified_name.rs

@@ -67,6 +67,10 @@ mod xml {
             writer.encode_child("Name", &self.name, context)?;
             Ok(())
         }
+
+        fn is_null_xml(&self) -> bool {
+            self.is_null()
+        }
     }
 
     impl XmlDecodable for QualifiedName {

async-opcua-types/src/string.rs

@@ -159,6 +159,10 @@ mod xml {
 
             Ok(())
         }
+
+        fn is_null_xml(&self) -> bool {
+            self.is_null()
+        }
     }
 
     impl XmlDecodable for UAString {

async-opcua-types/src/tests/xml.rs

@@ -359,7 +359,7 @@ fn from_xml_variant() {
         &Variant::from(EUInformation {
             namespace_uri: "https://my.namespace.uri".into(),
             unit_id: 1,
-            display_name: LocalizedText::new("en", "MyUnit"),
+            display_name: LocalizedText::from("MyUnit"),
             description: LocalizedText::new("en", "MyDesc"),
         }),
         r#"
@@ -369,7 +369,7 @@ fn from_xml_variant() {
                 <EUInformation>
                     <NamespaceUri>https://my.namespace.uri</NamespaceUri>
                     <UnitId>1</UnitId>
-                    <DisplayName><Locale>en</Locale><Text>MyUnit</Text></DisplayName>
+                    <DisplayName><Text>MyUnit</Text></DisplayName>
                     <Description><Locale>en</Locale><Text>MyDesc</Text></Description>
                 </EUInformation>
             </Body>

async-opcua-types/src/xml/builtins.rs

@@ -21,6 +21,10 @@ macro_rules! xml_enc_number {
                 writer.write_text(&self.to_string())?;
                 Ok(())
             }
+
+            fn is_null_xml(&self) -> bool {
+                *self == 0
+            }
         }
 
         impl XmlDecodable for $t {
@@ -63,6 +67,10 @@ macro_rules! xml_enc_float {
                 }
                 Ok(())
             }
+
+            fn is_null_xml(&self) -> bool {
+                *self == 0.0
+            }
         }
 
         impl XmlDecodable for $t {
@@ -165,6 +173,10 @@ impl XmlEncodable for bool {
         writer.write_text(if *self { "true" } else { "false" })?;
         Ok(())
     }
+
+    fn is_null_xml(&self) -> bool {
+        !self
+    }
 }
 
 impl<T> XmlType for Box<T>
@@ -200,6 +212,10 @@ where
     ) -> Result<(), Error> {
         self.as_ref().encode(writer, context)
     }
+
+    fn is_null_xml(&self) -> bool {
+        self.as_ref().is_null_xml()
+    }
 }
 
 impl<T> XmlType for Vec<T>
@@ -248,7 +264,11 @@ where
         context: &Context<'_>,
     ) -> super::EncodingResult<()> {
         for item in self {
-            writer.encode_child(item.tag(), item, context)?;
+            if item.is_null_xml() {
+                writer.write_empty(item.tag())?;
+            } else {
+                writer.encode_child(item.tag(), item, context)?;
+            }
         }
         Ok(())
     }
@@ -292,4 +312,8 @@ where
         }
         Ok(())
     }
+
+    fn is_null_xml(&self) -> bool {
+        self.is_none()
+    }
 }

async-opcua-types/src/xml/encoding.rs

@@ -55,6 +55,12 @@ pub trait XmlEncodable: XmlType {
         writer: &mut XmlStreamWriter<&mut dyn Write>,
         context: &Context<'_>,
     ) -> EncodingResult<()>;
+
+    /// This method should return `true` if the value is default
+    /// and should not be serialized.
+    fn is_null_xml(&self) -> bool {
+        false
+    }
 }
 
 /// Extensions for XmlStreamWriter.

async-opcua-xml/src/encoding/writer.rs

@@ -49,6 +49,13 @@ impl<T: Write> XmlStreamWriter<T> {
         Ok(())
     }
 
+    /// Write an empty tag to the stream.
+    pub fn write_empty(&mut self, tag: &str) -> Result<(), XmlWriteError> {
+        self.writer
+            .write_event(Event::Empty(BytesStart::new(tag)))?;
+        Ok(())
+    }
+
     /// Write node contents to the stream.
     pub fn write_text(&mut self, text: &str) -> Result<(), XmlWriteError> {
         self.writer.write_event(Event::Text(BytesText::new(text)))?;