Struct sauron::prelude::mt_dom::Attribute

pub struct Attribute<NS, ATT, VAL, EVENT, MSG> { /* fields omitted */ }

These are the plain attributes of an element

Implementations

impl<NS, ATT, VAL, EVENT, MSG> Attribute<NS, ATT, VAL, EVENT, MSG>

pub fn new(
    namespace: Option<NS>,
    name: ATT,
    value: VAL
) -> Attribute<NS, ATT, VAL, EVENT, MSG>

create a plain attribute with namespace

pub fn with_multiple_values(
    namespace: Option<NS>,
    name: ATT,
    value: Vec<VAL, Global>
) -> Attribute<NS, ATT, VAL, EVENT, MSG>

create from multiple values

pub fn name(&self) -> &ATT

return the name of this attribute

pub fn value(&self) -> &[AttValue<VAL, EVENT, MSG>]

return the value of this attribute

pub fn namespace(&self) -> Option<&NS>

return the namespace of this attribute

pub fn get_plain(&self) -> Vec<&VAL, Global>

return the plain value if it is a plain value

impl<NS, ATT, VAL, EVENT, MSG> Attribute<NS, ATT, VAL, EVENT, MSG> where
    MSG: 'static,
    EVENT: 'static, 

pub fn map_msg<F, MSG2>(self, func: F) -> Attribute<NS, ATT, VAL, EVENT, MSG2> where
    F: Fn(MSG) -> MSG2 + 'static,
    MSG2: 'static, 

map the msg

pub fn map_callback<MSG2>(
    self,
    cb: Callback<MSG, MSG2>
) -> Attribute<NS, ATT, VAL, EVENT, MSG2> where
    MSG2: 'static, 

transform the callback of this attribute

pub fn get_callback(&self) -> Vec<&Callback<EVENT, MSG>, Global>

return the callback values of this attribute

Trait Implementations

impl<NS, ATT, VAL, EVENT, MSG> Clone for Attribute<NS, ATT, VAL, EVENT, MSG> where
    NS: Clone,
    ATT: Clone,
    VAL: Clone, 

Note: using the #[derive(Debug)] needs EVENT and MSG to also be Debug

The reason this is manually implemented is, so that EVENT and MSG doesn't need to be Debug as it is part of the Callback objects and are not shown.

pub fn clone(&self) -> Attribute<NS, ATT, VAL, EVENT, MSG>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<NS, ATT, VAL, EVENT, MSG> Debug for Attribute<NS, ATT, VAL, EVENT, MSG> where
    NS: Debug,
    ATT: Debug,
    VAL: Debug, 

Note: using the #[derive(Debug)] needs EVENT and MSG to also be Debug

The reason this is manually implemented is, so that EVENT and MSG doesn't need to be Debug as it is part of the Callback objects and are not shown.

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<NS, ATT, VAL, EVENT, MSG> PartialEq<Attribute<NS, ATT, VAL, EVENT, MSG>> for Attribute<NS, ATT, VAL, EVENT, MSG> where
    NS: PartialEq<NS>,
    ATT: PartialEq<ATT>,
    VAL: PartialEq<VAL>, 

Note: using the #[derive(PartialEq)] needs EVENT and MSG to also be PartialEq.

The reason this is manually implemented is, so that EVENT and MSG doesn't need to be PartialEq as it is part of the Callback objects and are not compared

pub fn eq(&self, other: &Attribute<NS, ATT, VAL, EVENT, MSG>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<MSG> Render for Attribute<&'static str, &'static str, AttributeValue, Event, MSG>

pub fn render_with_indent(
    &self,
    buffer: &mut dyn Write,
    _indent: usize,
    _node_idx: &mut Option<usize>,
    _compressed: bool
) -> Result<(), Error>

render instance to a writable buffer with indention node_idx is for debugging purposes

pub fn render(&self, buffer: &mut dyn Write) -> Result<(), Error>

render the node to a writable buffer

pub fn render_compressed(&self, buffer: &mut dyn Write) -> Result<(), Error>

no new_lines, no indents

pub fn render_to_string(&self) -> String

render compressed html to string