qualname 0.0.2

Support for XML Namespaces Qualified Name
Documentation
#[cfg(test)]
use crate::unique_string::run_sequential_test;
use crate::{
    names::{NamespaceUri, NcName},
    unique_string::UniqueString,
};
use std::{
    fmt::Debug,
    hash::{Hash, Hasher},
};

/// A Qualified Name interned for shared use.
#[derive(Clone)]
pub(crate) struct UniqueQName {
    namespace_uri: Option<NamespaceUri>,
    local_name: NcName,
    uriqualified: UniqueString,
}
impl UniqueQName {
    pub fn new(namespace_uri: Option<NamespaceUri>, local_name: NcName) -> Self {
        let uriqualified = format!(
            "{}{}",
            namespace_uri.as_ref().map_or_else(
                || String::new(),
                |ns| {
                    let mut result = String::from("Q");
                    result.push('{');
                    result.push_str(ns.to_string().as_str());
                    result.push('}');
                    result
                }
            ),
            local_name.to_string()
        );
        let qual_uniq = UniqueString::from(uriqualified.as_str());
        UniqueQName {
            namespace_uri: namespace_uri,
            local_name: local_name,
            uriqualified: qual_uniq,
        }
    }
    pub fn namespace_uri(&self) -> Option<NamespaceUri> {
        self.namespace_uri.clone()
    }
    pub fn local_name(&self) -> NcName {
        self.local_name.clone()
    }
}
impl PartialEq for UniqueQName {
    fn eq(&self, other: &Self) -> bool {
        self.uriqualified.eq(&other.uriqualified)
    }
}
impl Eq for UniqueQName {}

impl Hash for UniqueQName {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.uriqualified.hash(state)
    }
}

impl Debug for UniqueQName {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.uriqualified.to_string())
    }
}

#[test]
fn test_add_and_drop() {
    run_sequential_test(|| {
        let initial_count = UniqueString::count();
        let s = UniqueQName::new(
            Some(NamespaceUri::try_from("hello").unwrap()),
            NcName::try_from("ok").unwrap(),
        );
        assert_eq!(UniqueString::count(), initial_count + 3);
        drop(s);
        assert_eq!(UniqueString::count(), initial_count);
    })
}

#[test]
fn test_add_clone_and_drop() {
    run_sequential_test(|| {
        let initial_count = UniqueString::count();
        let ns = NamespaceUri::try_from("hello").unwrap();
        let s1 = UniqueQName::new(Some(ns.clone()), NcName::try_from("ok").unwrap());
        assert_eq!(UniqueString::count(), initial_count + 3);
        let s2 = UniqueQName::new(Some(ns), NcName::try_from("ok").unwrap());
        assert_eq!(UniqueString::count(), initial_count + 3);
        drop(s1);
        assert_eq!(UniqueString::count(), initial_count + 3);
        drop(s2);
        assert_eq!(UniqueString::count(), initial_count);
    })
}

#[test]
fn test_multi_ns_add() {
    run_sequential_test(|| {
        for _iteration in 0..100 {
            let ns = NamespaceUri::try_from("ns1").unwrap();
            let s1 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-1").unwrap());
            let s2 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-2").unwrap());
            let s3 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-3").unwrap());
            let s4 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-4").unwrap());
            let s5 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-5").unwrap());
            let s6 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-6").unwrap());
            let s7 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-7").unwrap());
            let s8 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-8").unwrap());
            let s9 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-9").unwrap());
            let s10 = UniqueQName::new(Some(ns.clone()), NcName::try_from("some-name-10").unwrap());
            assert_eq!(s1.local_name().to_string(), "some-name-1");
            assert_eq!(s2.local_name().to_string(), "some-name-2");
            assert_eq!(s3.local_name().to_string(), "some-name-3");
            assert_eq!(s4.local_name().to_string(), "some-name-4");
            assert_eq!(s5.local_name().to_string(), "some-name-5");
            assert_eq!(s6.local_name().to_string(), "some-name-6");
            assert_eq!(s7.local_name().to_string(), "some-name-7");
            assert_eq!(s8.local_name().to_string(), "some-name-8");
            assert_eq!(s9.local_name().to_string(), "some-name-9");
            assert_eq!(s10.local_name().to_string(), "some-name-10")
        }
    });
}

#[test]
fn test_multi_none_add() {
    run_sequential_test(|| {
        for _iteration in 0..100 {
            let s1 = UniqueQName::new(None, NcName::try_from("some-name-1").unwrap());
            let s2 = UniqueQName::new(None, NcName::try_from("some-name-2").unwrap());
            let s3 = UniqueQName::new(None, NcName::try_from("some-name-3").unwrap());
            let s4 = UniqueQName::new(None, NcName::try_from("some-name-4").unwrap());
            let s5 = UniqueQName::new(None, NcName::try_from("some-name-5").unwrap());
            let s6 = UniqueQName::new(None, NcName::try_from("some-name-6").unwrap());
            let s7 = UniqueQName::new(None, NcName::try_from("some-name-7").unwrap());
            let s8 = UniqueQName::new(None, NcName::try_from("some-name-8").unwrap());
            let s9 = UniqueQName::new(None, NcName::try_from("some-name-9").unwrap());
            let s10 = UniqueQName::new(None, NcName::try_from("some-name-10").unwrap());
            assert_eq!(s1.local_name().to_string(), "some-name-1");
            assert_eq!(s2.local_name().to_string(), "some-name-2");
            assert_eq!(s3.local_name().to_string(), "some-name-3");
            assert_eq!(s4.local_name().to_string(), "some-name-4");
            assert_eq!(s5.local_name().to_string(), "some-name-5");
            assert_eq!(s6.local_name().to_string(), "some-name-6");
            assert_eq!(s7.local_name().to_string(), "some-name-7");
            assert_eq!(s8.local_name().to_string(), "some-name-8");
            assert_eq!(s9.local_name().to_string(), "some-name-9");
            assert_eq!(s10.local_name().to_string(), "some-name-10")
        }
    });
}