Struct html_types::node::Element

pub struct Element<'a, T> where
    T: ElementType,  {
    pub name: Tag<'a>,
    pub attributes: HashMap<Attribute<'a>, Option<Value<'a>>>,
    pub children: T,
}

The html element type. This is the most common Note: if children is None, then it is handled as an empty element, this is different than having no children

Fields

name: Tag<'a>

attributes: HashMap<Attribute<'a>, Option<Value<'a>>>

children: T

Implementations

impl<'a> Element<'a, Vec<Node<'a>>>

pub fn push<N>(&mut self, node: N) where
    N: Into<Node<'a>>, 

Pushes a child not into the element Note: you can also do this yourself, but this is nicer as it will coerce anything that can be a node into a node

pub fn anchor(url: Value<'a>, label: Text) -> Self

Helper function to create a link given the label and url

pub fn body<N>(children: Vec<N>) -> Self where
    N: Into<Node<'a>>, 

Creates a body element. Note consumes the children vector

pub fn html(
    header: Element<'a, Vec<Node<'a>>>,
    body: Element<'a, Vec<Node<'a>>>
) -> Self

Creates the html element Helper here assumes you have a body and header. as thats's used pretty much always

pub fn title(title: Text) -> Self

Creates a html title, with the supplied text

impl<'a, T> Element<'a, T> where
    T: ElementType, 

pub fn create(name: Tag<'a>) -> Self

Creates a typical element with children, from the provided tag name. This is the typical case

pub fn set_bool_attribute(&mut self, key: Attribute<'a>)

Sets the supplied attribute as a 'boolean' attribute This means it will just appear in the html, and will not render with a =value eg

pub fn set_attribute(&mut self, key: Attribute<'a>, value: Value<'a>)

Sets the attribute to the supplied value Note: sugar over wrapping the value with some.

Trait Implementations

impl<'a, T: Clone> Clone for Element<'a, T> where
    T: ElementType, 

fn clone(&self) -> Element<'a, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> From<Element<'a, ()>> for Node<'a>

fn from(original: Element<'a, ()>) -> Node<'a>

Performs the conversion.

impl<'a> From<Element<'a, Vec<Node<'a>>>> for Node<'a>

fn from(original: Element<'a, Vec<Node<'a>>>) -> Node<'a>

Performs the conversion.