Struct Context

pub struct Context { /* private fields */ }

A data structure designed to provide a high-level language agnostic calling convention.

Implementations

impl Context

pub fn new() -> Context

Create an empty context.

pub fn overlay(&self, another: &Context) -> Context

Overlay another on top of this context.

Example

let eg = Context::from("a: 1\nb: 0");
let another = Context::from("b: 1");
assert_eq!(eg.overlay(&another), Context::from("a: 1\nb: 1"));

pub fn render(&self, values: &Context) -> Context

Use as a template and render it with other values

Example

let template = Context::from("a: 1\nb: 0");
let values = Context::from("b: 1\nc: 2");
assert_eq!(template.render(&values), Context::from("a: 1\nb: 1"));

Note that this is recursive!

let template = Context::from("a: 1\nb:\n  b1: 0");
let values = Context::from("b:\n  b1: 1\n  b2: 2\nc: 2");
assert_eq!(template.render(&values), Context::from("a: 1\nb:\n  b1: 1"));

pub fn set(&self, key: &str, val: CtxObj) -> Context

Set a context element.

Example

let eg = Context::from("a: 1\nb: 0");
assert_eq!(eg.set("b", CtxObj::Int(1)), Context::from("a: 1\nb: 1"));

pub fn set_opt(&self, key: &str, optional: Option<CtxObj>) -> Context

Optionally set a context element. (Syntax sugar to adapt to Option)

Example

let eg = Context::from("a: 1\nb: 0");
assert_eq!(eg.set_opt("b", Some(CtxObj::Int(1))), Context::from("a: 1\nb: 1"));
assert_eq!(eg.set_opt("b", None), Context::from("a: 1\nb: 0"));

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

Get an element by reference if the key exists.

Example

let eg = Context::from("a: 1");
assert_eq!(eg.get("a").unwrap().clone(), CtxObj::Int(1));
assert_eq!(eg.get("b"), None);

pub fn get_clone(&self, key: &str) -> Option<CtxObj>

Get an element by value if the key exists.

Example

let eg = Context::from("a: 1");
assert_eq!(eg.get_clone("a").unwrap(), CtxObj::Int(1));
assert_eq!(eg.get_clone("b"), None);

pub fn unpack<T>(&self, key: &str) -> Result<T, CtxObjUnpackError>

where T: CtxObjUnpack,

Unpack an element by key if it exists.

Example

let eg = Context::from("a: 1");
let success: i64 = eg.unpack("a").unwrap();
assert_eq!(success, 1);
 
/*Although, beware of auto-conversion due to polymorphism with the CtxObjUnpack trait.*/
let success: i32 = eg.unpack("a").unwrap();
assert_eq!(success, 1);

This should fail because the key specified does not exist.

let eg = Context::from("a: 1");
let err: i64 = match eg.unpack("b") {
    Ok(v) => v,
    Err(_) => panic!()
};

This should also fail because the type conversion is not feasible.

let eg = Context::from("a: 1");
let err: String = match eg.unpack("b") {
    Ok(v) => v,
    Err(_) => panic!()
};

pub fn subcontext(&self, key: &str) -> Option<Context>

Enter a nested context.

Example

let eg = Context::from("s:\n  a: 1");
assert_eq!(eg.subcontext("s"), Some(Context::from("a: 1")));

pub fn list_contexts(&self, key: &str) -> Option<Vec<Context>>

List nested contexts.

Example

let eg = Context::from("s:\n- a: 1\n- b: 1");
assert_eq!(eg.list_contexts("s"), Some(vec![Context::from("a: 1"), Context::from("b: 1")]));

pub fn hide(&self, key: &str) -> Context

Hide an element by key if it exists.

Example

let eg = Context::from("a: 1\nb: 1");
assert_eq!(eg.hide("b"), Context::from("a: 1"));
assert_eq!(eg.hide("c"), eg);

pub fn keys( &self, ) -> Map<Map<IterArc<'_, String, CtxObj>, fn(&Arc<Entry<String, CtxObj>>) -> (&String, &CtxObj)>, fn((&String, &CtxObj)) -> &String>

Get all keys from this context.

Example

let eg = Context::from("a: 1\nb: 1");
let keys: std::collections::HashSet<String> = eg.keys().map(|k| { k.to_owned() }).collect();
assert_eq!(keys, vec![String::from("a"), String::from("b")].into_iter().collect());

Trait Implementations

impl Clone for Context

fn clone(&self) -> Context

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Context

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Context

fn deserialize<__D>( __deserializer: __D, ) -> Result<Context, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Context

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

Formats the value using the given formatter.

impl<'a> From<&'a str> for Context

fn from(s: &str) -> Context

Converts to this type from the input type.

impl From<Yaml> for Context

fn from(src: Yaml) -> Context

Converts to this type from the input type.

impl<'a> Index<&'a str> for Context

type Output = CtxObj

The returned type after indexing.

fn index(&self, key: &'a str) -> &CtxObj

Performs the indexing (container[index]) operation.

impl Into<Yaml> for Context

fn into(self) -> Yaml

Converts this type into the (usually inferred) input type.

impl PartialEq for Context

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Context