Struct Values

pub struct Values { /* private fields */ }

The Values type is used as the source of content during template expansion, and is a logical map of keys to typed Value (which may or may not be present during expansion).

Implementations

impl Values

pub fn add(self, key: impl Into<String>, value: impl Into<Value>) -> Self

Adds a new Value to the Values collection and returns the modified collection to allow for chaining of calls during construction. Values may be any type which implements Into<Value>

• this will generally be a concrete Value but may be your own type for which this trait has been implemented.

For clarity, it may be better to implement a suitable iterator trait for your custom type and pass it to the relevant Value construction function, as this will make the shape of data produced more obvious for anyone reading the code.

Examples found in repository

examples/simple.rs (line 12)

fn main() -> Result<(), Box<dyn Error>> {
    let template = Template::parse("/hello/{name}{/library*}")?;
    let values = Values::default()
        .add("name", Value::item("world"))
        .add("library", Value::list(["uri", "template", "system"]));

    assert_eq!(
        template.expand(&values)?,
        "/hello/world/uri/template/system"
    );

    Ok(())
}

pub fn get(&self, key: &str) -> Option<&Value>

Gets the Value at the given key from the Values collection if it exists.

Trait Implementations

impl Clone for Values

fn clone(&self) -> Values

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Values

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

Formats the value using the given formatter.

impl Default for Values

fn default() -> Values

Returns the “default value” for a type.

impl FromIterator<(String, Value)> for Values

fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> Self

Creates a value from an iterator.

impl PartialEq for Values

fn eq(&self, other: &Values) -> 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 Eq for Values

impl StructuralPartialEq for Values