Struct lignin::Element

pub struct Element<'a, S: ThreadSafety> {
    pub name: &'a str,
    pub creation_options: ElementCreationOptions<'a>,
    pub attributes: &'a [Attribute<'a>],
    pub content: Node<'a, S>,
    pub event_bindings: &'a [EventBinding<'a, S>],
}

Vdom Represents a single HTMLElement as name, attributes, content and event_bindings.

Fields

name: &'a str

The Element.tag_name.

Unlike in the browser, this is generally treated case-sensitively, meaning for example "div" doesn’t equal "DIV".

Since browsers will generally return the canonical uppercase name, it’s recommended to generate the VDOM all-uppercase too, to avoid unnecessary mismatches.

creation_options: ElementCreationOptions<'a>

Controls the options parameter of Document.createElement() or (currently only) the global is attribute.

attributes: &'a [Attribute<'a>]

The Element.attributes.

Note that while this collection is unordered in the browser, reordering attributes will generally affect diffing performance.

content: Node<'a, S>

Maps to Node.childNodes.

event_bindings: &'a [EventBinding<'a, S>]

DOM event bindings requested by a component.

See EventBinding for more information.

Implementations

impl<'a, S: ThreadSafety> Element<'a, S>

#[must_use]

pub fn deanonymize(self) -> Self

👎 Deprecated:

Call of .deanonymize() on named type.

When called on an opaque type, deanonymizes it into the underlying named type.

Both AutoSafe and Deanonymize must be in scope and the method must be called without qualification for this to work.

Calling this method on a named type returns the value and type unchanged and produces a deprecation warning.

impl<'a> Element<'a, ThreadSafe>

#[must_use]

pub fn prefer_thread_safe(self) -> Self

Gently nudges the compiler to choose the ThreadSafe version of a value if both are possible.

This method is by value, so it will resolve with higher priority than the by-reference method on the ThreadBound type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

#[must_use]

pub fn prefer_thread_safe_ref(&self) -> &Self

Gently nudges the compiler to choose the ThreadSafe version of a reference if both are possible.

This method is once by single reference, so it will resolve with higher priority than the twice-by-reference method on the ThreadBound type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

impl<'a> Element<'a, ThreadBound>

#[must_use]

pub fn prefer_thread_safe(&self) -> Self

Gently nudges the compiler to choose the ThreadSafe version of a value if both are is possible.

This method is by reference, so it will resolve with lower priority than the by-value method on the ThreadSafe type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

#[must_use]

pub fn prefer_thread_safe_ref<'b>(self: &&'b Self) -> &'b Self

Gently nudges the compiler to choose the ThreadSafe version of a reference if both are is possible.

This method is twice by reference, so it will resolve with lower priority than the once-by-reference method on the ThreadSafe type.

Note that not all tooling will show the correct overload here, but the compiler knows which to pick.

impl<'a, S> Element<'a, S> where
    S: ThreadSafety, 

#[must_use]

pub fn as_html(&'a self) -> Node<'a, S>

Wraps a reference to this Element inside a Node::HtmlElement without dom_binding.

Example

use lignin::{ElementCreationOptions, Node, ThreadSafe};

fn allocate<'a, T>(value: T) -> &'a T {
  // […]
}

let html_node: Node<ThreadSafe> = allocate(lignin::Element {
  name: "DIV",
  creation_options: ElementCreationOptions::new(),
  attributes: &[],
  content: Node::Multi(&[]),
  event_bindings: &[],
}).as_html();

#[must_use]

pub fn as_svg(&'a self) -> Node<'a, S>

Wraps a reference to this Element inside a Node::SvgElement without dom_binding.

Example

use lignin::{ElementCreationOptions, Node, ThreadSafe};

fn allocate<'a, T>(value: T) -> &'a T {
  // […]
}

let svg_node: Node<ThreadSafe> = allocate(lignin::Element {
  name: "SVG",
  creation_options: ElementCreationOptions::new(),
  attributes: &[],
  content: Node::Multi(&[]),
  event_bindings: &[],
}).as_svg();

Trait Implementations

impl<'a, S1, S2> Align<Element<'a, S2>> for Element<'a, S1> where
    S1: ThreadSafety + Into<S2>,
    S2: ThreadSafety, 

Not derived from the Into constraints on $Name directly since those are too broad.

fn align(self) -> T

Contextually thread-binds an instance, or not. Use only without qualification.

fn align_ref(&self) -> &T

Contextually thread-binds a reference, or not. Use only without qualification.

impl<'a, S> Clone for Element<'a, S> where
    S: ThreadSafety, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, S> Copy for Element<'a, S> where
    S: ThreadSafety, 

impl<'a, V> Deanonymize<Element<'a, ThreadSafe>> for V where
    V: Send + Sync + AutoSafe<Element<'a, ThreadBound>>, 

#[must_use]

fn deanonymize(self) -> SafeVariant

Deanonymize towards a compatible concrete type.

impl<'a, S> Debug for Element<'a, S> where
    S: ThreadSafety, 

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

Formats the value using the given formatter.

impl<'a, S> Eq for Element<'a, S> where
    S: ThreadSafety, 

impl<'a> From<Element<'a, ThreadSafe>> for Element<'a, ThreadBound>

fn from(thread_safe: Element<'a, ThreadSafe>) -> Self

Performs the conversion.

impl<'a, S> Hash for Element<'a, S> where
    S: ThreadSafety, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a, S> Ord for Element<'a, S> where
    S: ThreadSafety, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a, S1, S2> PartialEq<Element<'a, S2>> for Element<'a, S1> where
    S1: ThreadSafety,
    S2: ThreadSafety, 

fn eq(&self, other: &Element<'a, S2>) -> 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<'a, S1, S2> PartialOrd<Element<'a, S2>> for Element<'a, S1> where
    S1: ThreadSafety,
    S2: ThreadSafety, 

fn partial_cmp(&self, other: &Element<'a, S2>) -> Option<Ordering>

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

#[must_use]

pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]

pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]

pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]

pub fn ge(&self, other: &Rhs) -> bool

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

impl<'a, S> Vdom for Element<'a, S> where
    S: ThreadSafety, 

type ThreadSafety = S

The ThreadSafety of the Vdom type, either ThreadSafe or ThreadBound.