use crate::node::{Attribute, Node};
use std::fmt::Debug;
#[derive(Clone, Debug, PartialEq, Default)]
pub struct Element<NS, TAG, LEAF, ATT, VAL>
where
NS: PartialEq + Clone + Debug,
TAG: PartialEq + Debug,
LEAF: PartialEq + Clone + Debug,
ATT: PartialEq + Clone + Debug,
VAL: PartialEq + Clone + Debug,
{
pub namespace: Option<NS>,
pub tag: TAG,
pub attrs: Vec<Attribute<NS, ATT, VAL>>,
pub children: Vec<Node<NS, TAG, LEAF, ATT, VAL>>,
pub self_closing: bool,
}
impl<NS, TAG, LEAF, ATT, VAL> Element<NS, TAG, LEAF, ATT, VAL>
where
NS: PartialEq + Clone + Debug,
TAG: PartialEq + Debug,
LEAF: PartialEq + Clone + Debug,
ATT: PartialEq + Clone + Debug,
VAL: PartialEq + Clone + Debug,
{
pub fn new(
namespace: Option<NS>,
tag: TAG,
attrs: impl IntoIterator<Item = Attribute<NS, ATT, VAL>>,
children: impl IntoIterator<Item = Node<NS, TAG, LEAF, ATT, VAL>>,
self_closing: bool,
) -> Self {
let children = children
.into_iter()
.flat_map(|child| match child {
Node::NodeList(node_list) => node_list,
_ => vec![child],
})
.collect();
Self {
namespace,
tag,
attrs: attrs.into_iter().collect(),
children,
self_closing,
}
}
pub fn add_attributes(
&mut self,
attrs: impl IntoIterator<Item = Attribute<NS, ATT, VAL>>,
) {
self.attrs.extend(attrs)
}
pub fn add_children(
&mut self,
children: impl IntoIterator<Item = Node<NS, TAG, LEAF, ATT, VAL>>,
) {
self.children.extend(children.into_iter());
}
pub fn get_children(&self) -> &[Node<NS, TAG, LEAF, ATT, VAL>] {
&self.children
}
pub fn children_mut(&mut self) -> &mut [Node<NS, TAG, LEAF, ATT, VAL>] {
&mut self.children
}
pub fn swap_remove_child(
&mut self,
index: usize,
) -> Node<NS, TAG, LEAF, ATT, VAL> {
self.children.swap_remove(index)
}
pub fn swap_children(&mut self, a: usize, b: usize) {
self.children.swap(a, b)
}
pub fn take_children(self) -> Vec<Node<NS, TAG, LEAF, ATT, VAL>> {
self.children
}
pub fn get_attributes(&self) -> &[Attribute<NS, ATT, VAL>] {
&self.attrs
}
pub fn take_attributes(self) -> Vec<Attribute<NS, ATT, VAL>> {
self.attrs
}
pub fn namespace(&self) -> Option<&NS> {
self.namespace.as_ref()
}
pub fn tag(&self) -> &TAG {
&self.tag
}
pub fn take_tag(self) -> TAG {
self.tag
}
pub fn set_tag(&mut self, tag: TAG) {
self.tag = tag;
}
pub fn remove_attribute(&mut self, key: &ATT) {
self.attrs.retain(|att| att.name != *key)
}
pub fn set_attributes(
&mut self,
attrs: impl IntoIterator<Item = Attribute<NS, ATT, VAL>>,
) {
for attr in attrs {
self.remove_attribute(&attr.name);
self.attrs.push(attr);
}
}
pub fn merge_attributes(
&mut self,
new_attrs: impl IntoIterator<Item = Attribute<NS, ATT, VAL>>,
) {
for new_att in new_attrs {
if let Some(existing_attr) =
self.attrs.iter_mut().find(|att| att.name == new_att.name)
{
existing_attr.value.extend(new_att.value);
} else {
self.attrs.push(new_att);
}
}
}
pub fn get_attribute_value(&self, name: &ATT) -> Option<Vec<&VAL>> {
let result: Vec<&VAL> = self
.attrs
.iter()
.filter(|att| att.name == *name)
.flat_map(|att| att.value())
.collect();
if result.is_empty() {
None
} else {
Some(result)
}
}
}