qualname 0.0.1

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::{
    //collections::HashSet,
    hash::{Hash, Hasher},
    //sync::{Arc, LazyLock, RwLock},
};

/// A Qualified Name interned for shared use.
#[derive(Clone, Debug)]
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 Hash for UniqueQNameInner {
    fn hash<H: Hasher>(&self, state: &mut H) {
        eprintln!("qname hash");
        if let Some(ns) = self.namespace_uri.as_ref() {
            let mut uqn = String::new();
            uqn.push('{');
            uqn.push_str(ns.to_string().as_str());
            uqn.push('}');
            uqn.push_str(self.local_name.0.to_string().as_str());
            uqn.hash(state);
        } else {
            self.local_name.0.hash(state);
        }
        //self.namespace_uri.as_ref().map(|ns| ns.0.hash(state));
        //self.local_name.0.hash(state);
    }
}*/
impl PartialEq for UniqueQName {
    fn eq(&self, other: &Self) -> bool {
        self.uriqualified.eq(&other.uriqualified)
        /*self.namespace_uri.as_ref().map_or_else(
            || other.namespace_uri.is_none() && &self.local_name.0.0 == &other.local_name.0.0,
            |sns| {
                other.namespace_uri.as_ref().is_some_and(|ons| {
                    &sns.0.0 == &ons.0.0 && &self.local_name.0.0 == &other.local_name.0.0
                })
            },
        )*/
    }
}
impl Eq for UniqueQName {}

/*struct QNameMap {
    map: HashSet<Arc<UniqueQNameInner>>,
    released_ids: Vec<u32>,
    next_id: u32,
}

impl QNameMap {
    fn new() -> Self {
        Self {
            map: HashSet::new(),
            released_ids: Vec::new(),
            next_id: 0,
        }
    }
    fn next_id(&mut self) -> u32 {
        if let Some(id) = self.released_ids.pop() {
            id
        } else if let Some(plus_one) = self.next_id.checked_add_signed(1) {
            let next = self.next_id;
            self.next_id = plus_one;
            next
        } else {
            panic!("There are too many QNames.");
        }
    }
    fn release_id(&mut self, id: u32) {
        self.released_ids.push(id);
    }
}*/

//static UNIQUE_QNAMES: LazyLock<RwLock<QNameMap>> = LazyLock::new(|| RwLock::new(QNameMap::new()));
//static UNIQUE_QNAMES: LazyLock<RwLock<Vec<Option<UniqueQNameInner>>>> =
//    LazyLock::new(|| RwLock::new(Vec::new()));

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

#[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")
        }
    });
}