Struct Value

pub struct Value<'a>(/* private fields */);

Implementations

impl<'a> Value<'a>

pub const TEXT_CSS: Value<'static>

pub const STYLESHEET: Value<'static>

pub const UTF_8: Value<'static>

pub const EN: Value<'static>

pub fn is_valid(str: &str) -> bool

Function that determines whether a string slice would be considered a valid value. Can be helpful elsewhere when specifing more restrictive types

pub fn create(str: &'a str) -> Result<Value<'a>, InvalidValueError>

Examples found in repository

examples/simple.rs (line 13)

fn main() {
    // Create a link
    let link = {
        let label = Text::create("Click Me");
        let url = Value::create("http://google.com").unwrap();
        // Anchor is a helper for the typical case
        Element::anchor(url, label)
    };
    // Create the body. Sugar function takes a list of child nodes
    let body = Element::body(vec![link]);

    // Create a header manually. There isn't a sugar function here
    let header = {
        let mut el = Element::<Vec<Node>>::create(Tag::HEADER);
        let text = Text::create("Hello world");
        let title = Element::title(text);
        el.push(title);
        el
    };
    let html = Element::html(Value::EN, header, body);

    // Convert an element into a node
    let node: Node = html.into();

    // Nodes can be turned into HTML formatted strings
    let string: String = node.into();

    println!("{}", string);
}

pub fn owned<S>(str: S) -> Result<Value<'a>, InvalidValueError>

where S: Into<String>,

Trait Implementations

impl<'a> Clone for Value<'a>

fn clone(&self) -> Value<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Value<'a>

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

Formats the value using the given formatter.

impl<'a> Display for Value<'a>

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

Formats the value using the given formatter.

impl<'a> From<Id> for Value<'a>

fn from(value: Id) -> Self

Converts to this type from the input type.

impl<'a> From<Url> for Value<'a>

fn from(value: Url) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Value<'a>

fn eq(&self, other: &Value<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> TryFrom<Vec<Class>> for Value<'a>

type Error = EmptyVector

The type returned in the event of a conversion error.

fn try_from(value: Vec<Class>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> Eq for Value<'a>

impl<'a> StructuralPartialEq for Value<'a>