Struct domafic::dom_node::StringNode

pub struct StringNode<Message>(_, _, _);

DomNode wrapper for Strings

Trait Implementations

impl<Message: Clone> Clone for StringNode<Message>

fn clone(&self) -> StringNode<Message>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Message: Debug> Debug for StringNode<Message>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Message: Eq> Eq for StringNode<Message>

impl<Message: PartialEq> PartialEq for StringNode<Message>

fn eq(&self, __arg_0: &StringNode<Message>) -> bool

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

fn ne(&self, __arg_0: &StringNode<Message>) -> bool

This method tests for !=.

impl<Message: Hash> Hash for StringNode<Message>

fn hash<__HMessage: Hasher>(&self, __arg_0: &mut __HMessage)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<Message: Ord> Ord for StringNode<Message>

fn cmp(&self, __arg_0: &StringNode<Message>) -> Ordering

This method returns an Ordering between self and other.

impl<Message: PartialOrd> PartialOrd for StringNode<Message>

fn partial_cmp(&self, __arg_0: &StringNode<Message>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, __arg_0: &StringNode<Message>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, __arg_0: &StringNode<Message>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, __arg_0: &StringNode<Message>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, __arg_0: &StringNode<Message>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<M> DomNode for StringNode<M>

type Message = M

The type of message sent by a listener. Messages of this type should be used to update application state.

type Children = EmptyNodes<M>

The type of the set of children contained by the DomNode.

type Listeners = EmptyListeners<M>

The type of the set of listeners watching this DomNode for events.

type WithoutListeners = Self

The type of the DomNode with its listeners replaced by EmptyListeners.

fn key(&self) -> Option<u32>

If present, the key will be included in the KeyStack returned alongside a message. This should be used to differentiate messages from peer DomNodes.

fn get_attribute(&self, _index: usize) -> Option<&KeyValue>

Get the nth attribute for a given DomNode.

fn children(&self) -> &Self::Children

Returns a reference to the children of this DomNode

fn listeners(&self) -> &Self::Listeners

Returns a reference to the listeners listening for events on this DomNode

fn children_and_listeners(&self) -> (&Self::Children, &Self::Listeners)

Returns a reference to both the children and listeners of this DomNode

fn split_listeners(self) -> (Self::WithoutListeners, Self::Listeners)

Splits self into two separate components, one with and one without listeners.

fn value(&self) -> DOMValue

Returns an enum representing either the node's HTML tag or, in the case of a text node, the node's text value.

fn with_key(self, key: usize) -> WithKey<Self>

Add a key to this DomNode. This method will panic if the node already has a key.

fn displayable(&self) -> HtmlDisplayable<Self>

Returns a wrapper that can displayed as HTML

fn attributes(&self) -> AttributeIter<Self>

Returns an iterator over a DomNode's attributes.

fn with_attributes<A: AsRef<[KeyValue]>>(self,
                                         attributes: A)
                                         -> WithAttributes<Self, A>

Wrap the DomNode in an additional set of attributes.

fn with_listeners<L: Listeners<Message=Self::Message>>(self,
                                                       listeners: L)
                                                       -> WithListeners<Self::WithoutListeners, (L, Self::Listeners)>

Wrap the DomNode in an additional set of liseners.

impl<Message> From<String> for StringNode<Message>

fn from(string: String) -> Self

Performs the conversion.