#![no_std]
#![forbid(unsafe_code)]
#![warn(missing_docs)]
#![warn(missing_copy_implementations)]
#![warn(missing_debug_implementations)]
extern crate alloc;
#[cfg(feature = "std")]
extern crate std;
use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::num::NonZeroU32;
use core::ops::Range;
use alloc::vec::Vec;
mod parse;
mod tokenizer;
#[cfg(test)]
mod tokenizer_tests;
pub use crate::parse::*;
pub const NS_XML_URI: &str = "http://www.w3.org/XML/1998/namespace";
const NS_XML_PREFIX: &str = "xml";
pub const NS_XMLNS_URI: &str = "http://www.w3.org/2000/xmlns/";
const XMLNS: &str = "xmlns";
#[allow(missing_docs)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct TextPos {
pub row: u32,
pub col: u32,
}
impl TextPos {
pub fn new(row: u32, col: u32) -> TextPos {
TextPos { row, col }
}
}
impl fmt::Display for TextPos {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}:{}", self.row, self.col)
}
}
pub struct Document<'input> {
text: &'input str,
nodes: Vec<NodeData<'input>>,
attributes: Vec<AttributeData<'input>>,
namespaces: Namespaces<'input>,
}
impl<'input> Document<'input> {
#[inline]
pub fn root<'a>(&'a self) -> Node<'a, 'input> {
Node {
id: NodeId::new(0),
d: &self.nodes[0],
doc: self,
}
}
#[inline]
pub fn get_node<'a>(&'a self, id: NodeId) -> Option<Node<'a, 'input>> {
self.nodes.get(id.get_usize()).map(|data| Node {
id,
d: data,
doc: self,
})
}
#[inline]
pub fn root_element<'a>(&'a self) -> Node<'a, 'input> {
self.root()
.first_element_child()
.expect("XML documents must contain a root element")
}
#[inline]
pub fn descendants(&self) -> Descendants<'_, 'input> {
self.root().descendants()
}
#[inline]
pub fn text_pos_at(&self, pos: usize) -> TextPos {
tokenizer::Stream::new(self.text).gen_text_pos_from(pos)
}
#[inline]
pub fn input_text(&self) -> &'input str {
self.text
}
}
impl<'input> fmt::Debug for Document<'input> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
if !self.root().has_children() {
return write!(f, "Document []");
}
macro_rules! writeln_indented {
($depth:expr, $f:expr, $fmt:expr) => {
for _ in 0..$depth { write!($f, " ")?; }
writeln!($f, $fmt)?;
};
($depth:expr, $f:expr, $fmt:expr, $($arg:tt)*) => {
for _ in 0..$depth { write!($f, " ")?; }
writeln!($f, $fmt, $($arg)*)?;
};
}
fn print_into_iter<
T: fmt::Debug,
E: ExactSizeIterator<Item = T>,
I: IntoIterator<Item = T, IntoIter = E>,
>(
prefix: &str,
data: I,
depth: usize,
f: &mut fmt::Formatter,
) -> Result<(), fmt::Error> {
let data = data.into_iter();
if data.len() == 0 {
return Ok(());
}
writeln_indented!(depth, f, "{}: [", prefix);
for v in data {
writeln_indented!(depth + 1, f, "{:?}", v);
}
writeln_indented!(depth, f, "]");
Ok(())
}
fn print_children(
parent: Node,
depth: usize,
f: &mut fmt::Formatter,
) -> Result<(), fmt::Error> {
for child in parent.children() {
if child.is_element() {
writeln_indented!(depth, f, "Element {{");
writeln_indented!(depth, f, " tag_name: {:?}", child.tag_name());
print_into_iter("attributes", child.attributes(), depth + 1, f)?;
print_into_iter("namespaces", child.namespaces(), depth + 1, f)?;
if child.has_children() {
writeln_indented!(depth, f, " children: [");
print_children(child, depth + 2, f)?;
writeln_indented!(depth, f, " ]");
}
writeln_indented!(depth, f, "}}");
} else {
writeln_indented!(depth, f, "{:?}", child);
}
}
Ok(())
}
writeln!(f, "Document [")?;
print_children(self.root(), 1, f)?;
writeln!(f, "]")?;
Ok(())
}
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum NodeType {
Root,
Element,
PI,
Comment,
Text,
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
#[allow(missing_docs)]
pub struct PI<'input> {
pub target: &'input str,
pub value: Option<&'input str>,
}
#[derive(Clone, Copy, Debug)]
struct ShortRange {
start: u32,
end: u32,
}
impl From<Range<usize>> for ShortRange {
#[inline]
fn from(range: Range<usize>) -> Self {
debug_assert!(range.start <= core::u32::MAX as usize);
debug_assert!(range.end <= core::u32::MAX as usize);
ShortRange::new(range.start as u32, range.end as u32)
}
}
impl ShortRange {
#[inline]
fn new(start: u32, end: u32) -> Self {
ShortRange { start, end }
}
#[inline]
fn to_urange(self) -> Range<usize> {
self.start as usize..self.end as usize
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct NodeId(NonZeroU32);
impl NodeId {
#[inline]
pub fn new(id: u32) -> Self {
debug_assert!(id < core::u32::MAX);
NodeId(NonZeroU32::new(id + 1).unwrap())
}
#[inline]
pub fn get(self) -> u32 {
self.0.get() - 1
}
#[inline]
pub fn get_usize(self) -> usize {
self.get() as usize
}
}
impl From<u32> for NodeId {
#[inline]
fn from(id: u32) -> Self {
NodeId::new(id)
}
}
impl From<usize> for NodeId {
#[inline]
fn from(id: usize) -> Self {
debug_assert!(id <= core::u32::MAX as usize);
NodeId::new(id as u32)
}
}
#[derive(Debug)]
enum NodeKind<'input> {
Root,
Element {
tag_name: ExpandedNameIndexed<'input>,
attributes: ShortRange,
namespaces: ShortRange,
},
PI(PI<'input>),
Comment(StringStorage<'input>),
Text(StringStorage<'input>),
}
#[derive(Debug)]
struct NodeData<'input> {
parent: Option<NodeId>,
prev_sibling: Option<NodeId>,
next_subtree: Option<NodeId>,
last_child: Option<NodeId>,
kind: NodeKind<'input>,
#[cfg(feature = "positions")]
range: Range<usize>,
}
#[cfg(target_has_atomic = "ptr")]
type OwnedSharedString = alloc::sync::Arc<str>;
#[cfg(not(target_has_atomic = "ptr"))]
type OwnedSharedString = alloc::rc::Rc<str>;
#[derive(Clone, Eq, Debug)]
pub enum StringStorage<'input> {
Borrowed(&'input str),
Owned(OwnedSharedString),
}
impl StringStorage<'_> {
pub fn new_owned<T: Into<OwnedSharedString>>(s: T) -> Self {
StringStorage::Owned(s.into())
}
pub fn as_str(&self) -> &str {
match self {
StringStorage::Borrowed(s) => s,
StringStorage::Owned(s) => s,
}
}
}
impl PartialEq for StringStorage<'_> {
fn eq(&self, other: &Self) -> bool {
self.as_str() == other.as_str()
}
}
impl core::fmt::Display for StringStorage<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.as_str())
}
}
impl core::ops::Deref for StringStorage<'_> {
type Target = str;
fn deref(&self) -> &Self::Target {
self.as_str()
}
}
#[derive(Clone, Debug)]
struct AttributeData<'input> {
name: ExpandedNameIndexed<'input>,
value: StringStorage<'input>,
#[cfg(feature = "positions")]
pos: usize,
}
#[derive(Copy, Clone)]
pub struct Attribute<'a, 'input: 'a> {
doc: &'a Document<'input>,
data: &'a AttributeData<'input>,
}
impl<'a, 'input> Attribute<'a, 'input> {
#[inline]
pub fn namespace(&self) -> Option<&'a str> {
self.data.name.namespace(self.doc).map(Namespace::uri)
}
#[inline]
pub fn name(&self) -> &'input str {
self.data.name.local_name
}
#[inline]
pub fn value(&self) -> &'a str {
&self.data.value
}
#[inline]
pub fn value_storage(&self) -> &StringStorage<'input> {
&self.data.value
}
#[cfg(feature = "positions")]
#[inline]
pub fn position(&self) -> usize {
self.data.pos
}
}
impl PartialEq for Attribute<'_, '_> {
#[inline]
fn eq(&self, other: &Attribute<'_, '_>) -> bool {
self.data.name.as_expanded_name(self.doc) == other.data.name.as_expanded_name(other.doc)
&& self.data.value == other.data.value
}
}
impl fmt::Debug for Attribute<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
write!(
f,
"Attribute {{ name: {:?}, value: {:?} }}",
self.data.name.as_expanded_name(self.doc),
self.data.value
)
}
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct Namespace<'input> {
name: Option<&'input str>,
uri: StringStorage<'input>,
}
impl<'input> Namespace<'input> {
#[inline]
pub fn name(&self) -> Option<&'input str> {
self.name
}
#[inline]
pub fn uri(&self) -> &str {
self.uri.as_ref()
}
}
#[derive(Default)]
struct Namespaces<'input> {
values: Vec<Namespace<'input>>,
tree_order: Vec<NamespaceIdx>,
sorted_order: Vec<NamespaceIdx>,
}
impl<'input> Namespaces<'input> {
fn push_ns(
&mut self,
name: Option<&'input str>,
uri: StringStorage<'input>,
) -> Result<(), Error> {
debug_assert_ne!(name, Some(""));
let idx = match self.sorted_order.binary_search_by(|idx| {
let value = &self.values[idx.0 as usize];
(value.name, value.uri.as_ref()).cmp(&(name, uri.as_str()))
}) {
Ok(sorted_idx) => self.sorted_order[sorted_idx],
Err(sorted_idx) => {
if self.values.len() > core::u16::MAX as usize {
return Err(Error::NamespacesLimitReached);
}
let idx = NamespaceIdx(self.values.len() as u16);
self.values.push(Namespace { name, uri });
self.sorted_order.insert(sorted_idx, idx);
idx
}
};
self.tree_order.push(idx);
Ok(())
}
#[inline]
fn push_ref(&mut self, tree_idx: usize) {
let idx = self.tree_order[tree_idx];
self.tree_order.push(idx);
}
#[inline]
fn exists(&self, start: usize, prefix: Option<&str>) -> bool {
self.tree_order[start..]
.iter()
.any(|idx| self.values[idx.0 as usize].name == prefix)
}
fn shrink_to_fit(&mut self) {
self.values.shrink_to_fit();
self.tree_order.shrink_to_fit();
self.sorted_order.shrink_to_fit();
}
#[inline]
fn get(&self, idx: NamespaceIdx) -> &Namespace<'input> {
&self.values[idx.0 as usize]
}
}
#[derive(Clone, Copy, Debug)]
#[repr(transparent)]
struct NamespaceIdx(u16);
#[derive(Clone, Copy, Debug)]
struct ExpandedNameIndexed<'input> {
namespace_idx: Option<NamespaceIdx>,
local_name: &'input str,
}
impl<'input> ExpandedNameIndexed<'input> {
#[inline]
fn namespace<'a>(&self, doc: &'a Document<'input>) -> Option<&'a Namespace<'input>> {
self.namespace_idx.map(|idx| doc.namespaces.get(idx))
}
#[inline]
fn as_expanded_name<'a>(&self, doc: &'a Document<'input>) -> ExpandedName<'a, 'input> {
ExpandedName {
uri: self.namespace(doc).map(Namespace::uri),
name: self.local_name,
}
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct ExpandedName<'a, 'b> {
uri: Option<&'a str>,
name: &'b str,
}
impl<'a, 'b> ExpandedName<'a, 'b> {
#[inline]
pub fn namespace(&self) -> Option<&'a str> {
self.uri
}
#[inline]
pub fn name(&self) -> &'b str {
self.name
}
}
impl ExpandedName<'static, 'static> {
pub const fn from_static(uri: &'static str, name: &'static str) -> Self {
Self {
uri: Some(uri),
name,
}
}
}
impl fmt::Debug for ExpandedName<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self.namespace() {
Some(ns) => write!(f, "{{{}}}{}", ns, self.name),
None => write!(f, "{}", self.name),
}
}
}
impl<'a, 'b> From<&'b str> for ExpandedName<'a, 'b> {
#[inline]
fn from(v: &'b str) -> Self {
ExpandedName { uri: None, name: v }
}
}
impl<'a, 'b> From<(&'a str, &'b str)> for ExpandedName<'a, 'b> {
#[inline]
fn from(v: (&'a str, &'b str)) -> Self {
ExpandedName {
uri: Some(v.0),
name: v.1,
}
}
}
#[derive(Clone, Copy)]
pub struct Node<'a, 'input: 'a> {
id: NodeId,
doc: &'a Document<'input>,
d: &'a NodeData<'input>,
}
impl Eq for Node<'_, '_> {}
impl PartialEq for Node<'_, '_> {
#[inline]
fn eq(&self, other: &Self) -> bool {
(self.id, self.doc as *const _) == (other.id, other.doc as *const _)
}
}
impl PartialOrd for Node<'_, '_> {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl Ord for Node<'_, '_> {
fn cmp(&self, other: &Self) -> Ordering {
(self.id.0, self.doc as *const _).cmp(&(other.id.0, other.doc as *const _))
}
}
impl Hash for Node<'_, '_> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.id.0.hash(state);
(self.doc as *const Document).hash(state);
(self.d as *const NodeData).hash(state);
}
}
impl<'a, 'input: 'a> Node<'a, 'input> {
#[inline]
pub fn node_type(&self) -> NodeType {
match self.d.kind {
NodeKind::Root => NodeType::Root,
NodeKind::Element { .. } => NodeType::Element,
NodeKind::PI { .. } => NodeType::PI,
NodeKind::Comment(_) => NodeType::Comment,
NodeKind::Text(_) => NodeType::Text,
}
}
#[inline]
pub fn is_root(&self) -> bool {
self.node_type() == NodeType::Root
}
#[inline]
pub fn is_element(&self) -> bool {
self.node_type() == NodeType::Element
}
#[inline]
pub fn is_pi(&self) -> bool {
self.node_type() == NodeType::PI
}
#[inline]
pub fn is_comment(&self) -> bool {
self.node_type() == NodeType::Comment
}
#[inline]
pub fn is_text(&self) -> bool {
self.node_type() == NodeType::Text
}
#[inline]
pub fn document(&self) -> &'a Document<'input> {
self.doc
}
#[inline]
pub fn tag_name(&self) -> ExpandedName<'a, 'input> {
match self.d.kind {
NodeKind::Element { ref tag_name, .. } => tag_name.as_expanded_name(self.doc),
_ => "".into(),
}
}
pub fn has_tag_name<'n, 'm, N>(&self, name: N) -> bool
where
N: Into<ExpandedName<'n, 'm>>,
{
let name = name.into();
match self.d.kind {
NodeKind::Element { ref tag_name, .. } => match name.namespace() {
Some(_) => tag_name.as_expanded_name(self.doc) == name,
None => tag_name.local_name == name.name,
},
_ => false,
}
}
pub fn default_namespace(&self) -> Option<&'a str> {
self.namespaces()
.find(|ns| ns.name.is_none())
.map(|v| v.uri.as_ref())
}
pub fn lookup_prefix(&self, uri: &str) -> Option<&'input str> {
if uri == NS_XML_URI {
return Some(NS_XML_PREFIX);
}
self.namespaces()
.find(|ns| &*ns.uri == uri)
.map(|v| v.name)
.unwrap_or(None)
}
pub fn lookup_namespace_uri(&self, prefix: Option<&str>) -> Option<&'a str> {
self.namespaces()
.find(|ns| ns.name == prefix)
.map(|v| v.uri.as_ref())
}
pub fn attribute<'n, 'm, N>(&self, name: N) -> Option<&'a str>
where
N: Into<ExpandedName<'n, 'm>>,
{
let name = name.into();
self.attributes()
.find(|a| a.data.name.as_expanded_name(self.doc) == name)
.map(|a| a.value())
}
pub fn attribute_node<'n, 'm, N>(&self, name: N) -> Option<Attribute<'a, 'input>>
where
N: Into<ExpandedName<'n, 'm>>,
{
let name = name.into();
self.attributes()
.find(|a| a.data.name.as_expanded_name(self.doc) == name)
}
pub fn has_attribute<'n, 'm, N>(&self, name: N) -> bool
where
N: Into<ExpandedName<'n, 'm>>,
{
let name = name.into();
self.attributes()
.any(|a| a.data.name.as_expanded_name(self.doc) == name)
}
#[inline]
pub fn attributes(&self) -> Attributes<'a, 'input> {
Attributes::new(self)
}
#[inline]
pub fn namespaces(&self) -> NamespaceIter<'a, 'input> {
let namespaces = match self.d.kind {
NodeKind::Element { ref namespaces, .. } => {
&self.doc.namespaces.tree_order[namespaces.to_urange()]
}
_ => &[],
};
NamespaceIter {
doc: self.doc,
namespaces: namespaces.iter(),
}
}
#[inline]
pub fn text(&self) -> Option<&'a str> {
self.text_storage().map(|s| s.as_str())
}
pub fn text_storage(&self) -> Option<&'a StringStorage<'input>> {
match self.d.kind {
NodeKind::Element { .. } => match self.first_child() {
Some(child) if child.is_text() => match self.doc.nodes[child.id.get_usize()].kind {
NodeKind::Text(ref text) => Some(text),
_ => None,
},
_ => None,
},
NodeKind::Comment(ref text) => Some(text),
NodeKind::Text(ref text) => Some(text),
_ => None,
}
}
#[inline]
pub fn tail(&self) -> Option<&'a str> {
self.tail_storage().map(|s| s.as_str())
}
pub fn tail_storage(&self) -> Option<&'a StringStorage<'input>> {
if !self.is_element() {
return None;
}
match self.next_sibling().map(|n| n.id) {
Some(id) => match self.doc.nodes[id.get_usize()].kind {
NodeKind::Text(ref text) => Some(text),
_ => None,
},
None => None,
}
}
#[inline]
pub fn pi(&self) -> Option<PI<'input>> {
match self.d.kind {
NodeKind::PI(pi) => Some(pi),
_ => None,
}
}
#[inline]
pub fn parent(&self) -> Option<Self> {
self.d.parent.map(|id| self.doc.get_node(id).unwrap())
}
pub fn parent_element(&self) -> Option<Self> {
self.ancestors().skip(1).find(|n| n.is_element())
}
#[inline]
pub fn prev_sibling(&self) -> Option<Self> {
self.d.prev_sibling.map(|id| self.doc.get_node(id).unwrap())
}
pub fn prev_sibling_element(&self) -> Option<Self> {
self.prev_siblings().skip(1).find(|n| n.is_element())
}
#[inline]
pub fn next_sibling(&self) -> Option<Self> {
self.d
.next_subtree
.map(|id| self.doc.get_node(id).unwrap())
.and_then(|node| {
let possibly_self = node
.d
.prev_sibling
.expect("next_subtree will always have a previous sibling");
if possibly_self == self.id {
Some(node)
} else {
None
}
})
}
pub fn next_sibling_element(&self) -> Option<Self> {
self.next_siblings().skip(1).find(|n| n.is_element())
}
#[inline]
pub fn first_child(&self) -> Option<Self> {
self.d
.last_child
.map(|_| self.doc.get_node(NodeId::new(self.id.get() + 1)).unwrap())
}
pub fn first_element_child(&self) -> Option<Self> {
self.children().find(|n| n.is_element())
}
#[inline]
pub fn last_child(&self) -> Option<Self> {
self.d.last_child.map(|id| self.doc.get_node(id).unwrap())
}
pub fn last_element_child(&self) -> Option<Self> {
self.children().filter(|n| n.is_element()).last()
}
#[inline]
pub fn has_siblings(&self) -> bool {
self.d.prev_sibling.is_some() || self.next_sibling().is_some()
}
#[inline]
pub fn has_children(&self) -> bool {
self.d.last_child.is_some()
}
#[inline]
pub fn ancestors(&self) -> AxisIter<'a, 'input> {
AxisIter {
node: Some(*self),
next: Node::parent,
}
}
#[inline]
pub fn prev_siblings(&self) -> AxisIter<'a, 'input> {
AxisIter {
node: Some(*self),
next: Node::prev_sibling,
}
}
#[inline]
pub fn next_siblings(&self) -> AxisIter<'a, 'input> {
AxisIter {
node: Some(*self),
next: Node::next_sibling,
}
}
#[inline]
pub fn first_children(&self) -> AxisIter<'a, 'input> {
AxisIter {
node: Some(*self),
next: Node::first_child,
}
}
#[inline]
pub fn last_children(&self) -> AxisIter<'a, 'input> {
AxisIter {
node: Some(*self),
next: Node::last_child,
}
}
#[inline]
pub fn children(&self) -> Children<'a, 'input> {
Children {
front: self.first_child(),
back: self.last_child(),
}
}
#[inline]
pub fn descendants(&self) -> Descendants<'a, 'input> {
Descendants::new(*self)
}
#[cfg(feature = "positions")]
#[inline]
pub fn range(&self) -> Range<usize> {
self.d.range.clone()
}
#[inline]
pub fn id(&self) -> NodeId {
self.id
}
}
impl<'a, 'input: 'a> fmt::Debug for Node<'a, 'input> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self.d.kind {
NodeKind::Root => write!(f, "Root"),
NodeKind::Element { .. } => {
write!(
f,
"Element {{ tag_name: {:?}, attributes: {:?}, namespaces: {:?} }}",
self.tag_name(),
self.attributes(),
self.namespaces()
)
}
NodeKind::PI(pi) => {
write!(f, "PI {{ target: {:?}, value: {:?} }}", pi.target, pi.value)
}
NodeKind::Comment(ref text) => write!(f, "Comment({:?})", text.as_str()),
NodeKind::Text(ref text) => write!(f, "Text({:?})", text.as_str()),
}
}
}
#[derive(Clone)]
pub struct Attributes<'a, 'input> {
doc: &'a Document<'input>,
attrs: core::slice::Iter<'a, AttributeData<'input>>,
}
impl<'a, 'input> Attributes<'a, 'input> {
#[inline]
fn new(node: &Node<'a, 'input>) -> Attributes<'a, 'input> {
let attrs = match node.d.kind {
NodeKind::Element { ref attributes, .. } => {
&node.doc.attributes[attributes.to_urange()]
}
_ => &[],
};
Attributes {
doc: node.doc,
attrs: attrs.iter(),
}
}
}
impl<'a, 'input> Iterator for Attributes<'a, 'input> {
type Item = Attribute<'a, 'input>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.attrs.next().map(|attr| Attribute {
doc: self.doc,
data: attr,
})
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.attrs.nth(n).map(|attr| Attribute {
doc: self.doc,
data: attr,
})
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.attrs.size_hint()
}
}
impl<'a, 'input> DoubleEndedIterator for Attributes<'a, 'input> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.attrs.next_back().map(|attr| Attribute {
doc: self.doc,
data: attr,
})
}
}
impl ExactSizeIterator for Attributes<'_, '_> {}
impl fmt::Debug for Attributes<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.debug_struct("Attributes")
.field("attrs", &self.attrs)
.finish()
}
}
#[derive(Clone)]
pub struct AxisIter<'a, 'input: 'a> {
node: Option<Node<'a, 'input>>,
next: fn(&Node<'a, 'input>) -> Option<Node<'a, 'input>>,
}
impl<'a, 'input: 'a> Iterator for AxisIter<'a, 'input> {
type Item = Node<'a, 'input>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
let node = self.node.take();
self.node = node.as_ref().and_then(self.next);
node
}
}
impl fmt::Debug for AxisIter<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.debug_struct("AxisIter")
.field("node", &self.node)
.field("next", &"fn()")
.finish()
}
}
#[derive(Clone, Debug)]
pub struct Children<'a, 'input: 'a> {
front: Option<Node<'a, 'input>>,
back: Option<Node<'a, 'input>>,
}
impl<'a, 'input: 'a> Iterator for Children<'a, 'input> {
type Item = Node<'a, 'input>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
if self.front == self.back {
let node = self.front.take();
self.back = None;
node
} else {
let node = self.front.take();
self.front = node.as_ref().and_then(Node::next_sibling);
node
}
}
}
impl<'a, 'input: 'a> DoubleEndedIterator for Children<'a, 'input> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
if self.back == self.front {
let node = self.back.take();
self.front = None;
node
} else {
let node = self.back.take();
self.back = node.as_ref().and_then(Node::prev_sibling);
node
}
}
}
#[derive(Clone)]
pub struct Descendants<'a, 'input> {
doc: &'a Document<'input>,
nodes: core::iter::Enumerate<core::slice::Iter<'a, NodeData<'input>>>,
from: usize,
}
impl<'a, 'input> Descendants<'a, 'input> {
#[inline]
fn new(start: Node<'a, 'input>) -> Self {
let from = start.id.get_usize();
let until = start
.d
.next_subtree
.map(NodeId::get_usize)
.unwrap_or(start.doc.nodes.len());
let nodes = start.doc.nodes[from..until].iter().enumerate();
Self {
doc: start.doc,
nodes,
from,
}
}
}
impl<'a, 'input> Iterator for Descendants<'a, 'input> {
type Item = Node<'a, 'input>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.nodes.next().map(|(idx, data)| Node {
id: NodeId::from(self.from + idx),
d: data,
doc: self.doc,
})
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.nodes.nth(n).map(|(idx, data)| Node {
id: NodeId::from(self.from + idx),
d: data,
doc: self.doc,
})
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.nodes.size_hint()
}
}
impl<'a, 'input> DoubleEndedIterator for Descendants<'a, 'input> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.nodes.next_back().map(|(idx, data)| Node {
id: NodeId::from(self.from + idx),
d: data,
doc: self.doc,
})
}
}
impl ExactSizeIterator for Descendants<'_, '_> {}
impl fmt::Debug for Descendants<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.debug_struct("Descendants")
.field("nodes", &self.nodes)
.field("from", &self.from)
.finish()
}
}
#[derive(Clone)]
pub struct NamespaceIter<'a, 'input> {
doc: &'a Document<'input>,
namespaces: core::slice::Iter<'a, NamespaceIdx>,
}
impl<'a, 'input> Iterator for NamespaceIter<'a, 'input> {
type Item = &'a Namespace<'input>;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
self.namespaces
.next()
.map(|idx| self.doc.namespaces.get(*idx))
}
#[inline]
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.namespaces
.nth(n)
.map(|idx| self.doc.namespaces.get(*idx))
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
self.namespaces.size_hint()
}
}
impl<'a, 'input> DoubleEndedIterator for NamespaceIter<'a, 'input> {
#[inline]
fn next_back(&mut self) -> Option<Self::Item> {
self.namespaces
.next()
.map(|idx| self.doc.namespaces.get(*idx))
}
}
impl ExactSizeIterator for NamespaceIter<'_, '_> {}
impl fmt::Debug for NamespaceIter<'_, '_> {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
f.debug_struct("NamespaceIter")
.field("namespaces", &self.namespaces)
.finish()
}
}