Add helper method to check if xsi:nil value is set in attributes

Author: Mingun

Changelog.md

@@ -16,6 +16,7 @@
 ### New Features
 
 - [#850]: Add `Attribute::as_bool()` method to get an attribute value as a boolean.
+- [#850]: Add `Attributes::has_nil()` method to check if attributes has `xsi:nil` attribute set to `true`.
 
 ### Bug Fixes
 

src/events/attributes.rs

@@ -5,7 +5,8 @@
 use crate::encoding::Decoder;
 use crate::errors::Result as XmlResult;
 use crate::escape::{escape, resolve_predefined_entity, unescape_with};
-use crate::name::QName;
+use crate::name::{LocalName, Namespace, QName};
+use crate::reader::NsReader;
 use crate::utils::{is_whitespace, Bytes};
 
 use std::fmt::{self, Debug, Display, Formatter};
@@ -269,6 +270,81 @@ impl<'a> Attributes<'a> {
         self.state.check_duplicates = val;
         self
     }
+
+    /// Checks if the current tag has a [`xsi:nil`] attribute. This method ignores any errors in
+    /// attributes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use pretty_assertions::assert_eq;
+    /// use quick_xml::events::Event;
+    /// use quick_xml::name::QName;
+    /// use quick_xml::reader::NsReader;
+    ///
+    /// let mut reader = NsReader::from_str("
+    ///     <root xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'>
+    ///         <true xsi:nil='true'/>
+    ///         <false xsi:nil='false'/>
+    ///         <none/>
+    ///         <non-xsi xsi:nil='true' xmlns:xsi='namespace'/>
+    ///         <unbound-nil nil='true' xmlns='http://www.w3.org/2001/XMLSchema-instance'/>
+    ///         <another-xmlns f:nil='true' xmlns:f='http://www.w3.org/2001/XMLSchema-instance'/>
+    ///     </root>
+    /// ");
+    /// reader.config_mut().trim_text(true);
+    ///
+    /// macro_rules! check {
+    ///     ($reader:expr, $name:literal, $value:literal) => {
+    ///         let event = match $reader.read_event().unwrap() {
+    ///             Event::Empty(e) => e,
+    ///             e => panic!("Unexpected event {:?}", e),
+    ///         };
+    ///         assert_eq!(
+    ///             (event.name(), event.attributes().has_nil(&$reader)),
+    ///             (QName($name.as_bytes()), $value),
+    ///         );
+    ///     };
+    /// }
+    ///
+    /// let root = match reader.read_event().unwrap() {
+    ///     Event::Start(e) => e,
+    ///     e => panic!("Unexpected event {:?}", e),
+    /// };
+    /// assert_eq!(root.attributes().has_nil(&reader), false);
+    ///
+    /// // definitely true
+    /// check!(reader, "true",          true);
+    /// // definitely false
+    /// check!(reader, "false",         false);
+    /// // absence of the attribute means that attribute is not set
+    /// check!(reader, "none",          false);
+    /// // attribute not bound to the correct namespace
+    /// check!(reader, "non-xsi",       false);
+    /// // attributes without prefix not bound to any namespace
+    /// check!(reader, "unbound-nil",   false);
+    /// // prefix can be any while it is bound to the correct namespace
+    /// check!(reader, "another-xmlns", true);
+    /// ```
+    ///
+    /// [`xsi:nil`]: https://www.w3.org/TR/xmlschema-1/#xsi_nil
+    pub fn has_nil<R>(&mut self, reader: &NsReader<R>) -> bool {
+        use crate::name::ResolveResult::*;
+
+        self.any(|attr| {
+            if let Ok(attr) = attr {
+                match reader.resolve_attribute(attr.key) {
+                    (
+                        Bound(Namespace(b"http://www.w3.org/2001/XMLSchema-instance")),
+                        LocalName(b"nil"),
+                    ) => attr.as_bool().unwrap_or_default(),
+                    _ => false,
+                }
+            } else {
+                false
+            }
+        })
+    }
 }
 
 impl<'a> Debug for Attributes<'a> {

src/name.rs

@@ -200,7 +200,7 @@ impl<'a> AsRef<[u8]> for QName<'a> {
 /// [local (unqualified) name]: https://www.w3.org/TR/xml-names11/#dt-localname
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde-types", derive(serde::Deserialize, serde::Serialize))]
-pub struct LocalName<'a>(&'a [u8]);
+pub struct LocalName<'a>(pub(crate) &'a [u8]);
 impl<'a> LocalName<'a> {
     /// Converts this name to an internal slice representation.
     #[inline(always)]