use std::{collections::HashMap, fmt::Display, rc::Rc, sync::LazyLock};
use crate::{NamespacePrefix, NamespaceUri};
static XMLNSURI: LazyLock<NamespaceUri> =
LazyLock::new(|| NamespaceUri::try_from("http://www.w3.org/2000/xmlns/").unwrap());
static XMLNSPREFIX: LazyLock<Option<NamespacePrefix>> =
LazyLock::new(|| Some(NamespacePrefix(String::from("xmlns"))));
#[derive(Debug)]
pub struct InvalidNamespaceDeclaration;
impl Display for InvalidNamespaceDeclaration {
#[inline]
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Invalid namespace declaration")
}
}
impl std::error::Error for InvalidNamespaceDeclaration {}
#[derive(Clone, Debug)]
pub struct NamespaceDeclaration {
pub(crate) namespace_prefix: Option<NamespacePrefix>,
pub(crate) namespace_uri: NamespaceUri,
}
impl NamespaceDeclaration {
#[inline]
pub fn new(
namespace_prefix: Option<NamespacePrefix>,
namespace_uri: NamespaceUri,
) -> Result<Self, InvalidNamespaceDeclaration> {
if (namespace_prefix == XML.namespace_prefix && namespace_uri != XML.namespace_uri)
|| (namespace_prefix != XML.namespace_prefix && namespace_uri == XML.namespace_uri)
{
return Err(InvalidNamespaceDeclaration);
}
if (namespace_prefix == *XMLNSPREFIX && namespace_uri != *XMLNSURI)
|| (namespace_prefix != *XMLNSPREFIX && namespace_uri == *XMLNSURI)
{
return Err(InvalidNamespaceDeclaration);
}
Ok(Self {
namespace_prefix,
namespace_uri,
})
}
}
static XML: LazyLock<NamespaceDeclaration> = LazyLock::new(|| NamespaceDeclaration {
namespace_prefix: Some(NamespacePrefix::try_from("xml").unwrap()),
namespace_uri: NamespaceUri::try_from("http://www.w3.org/XML/1998/namespace").unwrap(),
});
#[derive(Clone, Debug)]
pub struct NamespaceMap {
prefixes: HashMap<Option<NamespacePrefix>, Rc<NamespaceDeclaration>>,
uris: HashMap<NamespaceUri, Rc<NamespaceDeclaration>>,
}
impl NamespaceMap {
pub fn new() -> Self {
let mut nm = Self {
prefixes: HashMap::new(),
uris: HashMap::new(),
};
nm.push(
NamespaceDeclaration::new(
Some(NamespacePrefix::try_from("xml").unwrap()),
NamespaceUri::try_from("http://www.w3.org/XML/1998/namespace").unwrap(),
)
.unwrap(),
);
nm
}
pub fn push(&mut self, nsd: NamespaceDeclaration) {
let nsdr = Rc::new(nsd.clone());
self.prefixes
.insert(nsd.namespace_prefix.clone(), nsdr.clone());
self.uris.insert(nsd.namespace_uri.clone(), nsdr);
}
pub fn namespace_uri(&self, prefix: &Option<NamespacePrefix>) -> Option<NamespaceUri> {
self.prefixes.get(prefix).map(|nd| nd.namespace_uri.clone())
}
pub fn prefix(&self, ns_uri: &NamespaceUri) -> Option<NamespacePrefix> {
self.uris
.get(ns_uri)
.map_or(None, |nd| nd.namespace_prefix.clone())
}
pub fn pop_prefix(&mut self, prefix: &Option<NamespacePrefix>) -> Option<NamespaceDeclaration> {
if let Some(nsd) = self.prefixes.remove(&prefix) {
self.uris.remove(&nsd.namespace_uri);
Some((*nsd).clone())
} else {
None
}
}
}