Enum uri_template_system_core::Value

pub enum Value {
    AssociativeArray(Vec<(String, String)>),
    Item(String),
    List(Vec<String>),
}

The Value type is used as the source of content during template expansion, as part of a Values collection. It maps to the three valid shapes of data defined by the RFC (a single item, a list of items, or a list of key/value pairs).

All values are of type String for simplicity of ownership, etc.

Variants

AssociativeArray(Vec<(String, String)>)

The Value::AssociativeArray variant allows for input data to be treated as a logical map (with implicit ordering), complying with the requirements for Level 4 templates defined in RFC6570 2.3.

Item(String)

The Value::Item variant allows for simple input data, complying with the requirements for sub-Level 4 templates defined in RFC6570 2.3.

List(Vec<String>)

The Value::List variant allows for input data to be treated as a logical list (with implicit ordering), complying with the requirements for Level 4 templates defined in RFC6570 2.3.

Implementations

impl Value

pub fn associative_array<T, U, V>(value: T) -> Selfwhere T: IntoIterator<Item = (U, V)>, U: Into<String>, V: Into<String>,

Constructs a new Value from any iterator which produces pairs (tuples) where both items implement Into<String>. This may be a simple array or vec, or a more complex type such as an IndexMap.

let expected = Value::AssociativeArray(Vec::from_iter([
    (String::from("a"), String::from("1")),
    (String::from("b"), String::from("2")),
]));

let array = [("a", "1"), ("b", "2")];
assert_eq!(expected, Value::associative_array(array));

let vec = Vec::from_iter(array);
assert_eq!(expected, Value::associative_array(vec));

pub fn item<T>(value: T) -> Selfwhere T: Into<String>,

Constructs a new Value from any type which implements Into<String>.

let expected = Value::Item(String::from("a"));

let str = "a";
assert_eq!(expected, Value::item(str));

let string = String::from(str);
assert_eq!(expected, Value::item(string));

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 list<T, U>(value: T) -> Selfwhere T: IntoIterator<Item = U>, U: Into<String>,

Constructs a new Value from any iterator which produces items which implement Into<String>, such as arrays, vecs, etc.

let expected = Value::List(Vec::from_iter([String::from("a"), String::from("b")]));

let array = ["a", "b"];
assert_eq!(expected, Value::list(array));

let vec = Vec::from_iter(array);
assert_eq!(expected, Value::list(vec));

Examples found in repository

examples/simple.rs (line 13)

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(())
}

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl PartialEq<Value> for Value

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

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

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

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

impl Eq for Value

impl StructuralEq for Value

impl StructuralPartialEq for Value