Struct StaticContextBuilder

pub struct StaticContextBuilder<N: Node, F: FnMut(&str) -> Result<(), Error>, G: FnMut(&str) -> Result<N, Error>, H: FnMut(&Url) -> Result<String, Error>>(/* private fields */);

Builder for a StaticContext. The main feature of the static context is the ability to set up a callback for messages.

use std::rc::Rc;
use xrust::{Error, ErrorKind};
use xrust::qname::QualifiedName;
use xrust::value::Value;
use xrust::item::{Item, Sequence, SequenceTrait, Node, NodeType};
use xrust::trees::smite::RNode;
use xrust::transform::Transform;
use xrust::transform::context::{Context, ContextBuilder, StaticContext, StaticContextBuilder};

let mut message = String::from("no message received");
let xform = Transform::LiteralElement(
  Rc::new(QualifiedName::new(None, None, String::from("Example"))),
  Box::new(Transform::SequenceItems(vec![
   Transform::Message(
       Box::new(Transform::Literal(Item::Value(Rc::new(Value::from("a message from the transformation"))))),
       None,
       Box::new(Transform::Empty),
       Box::new(Transform::Empty),
   ),
   Transform::Literal(Item::Value(Rc::new(Value::from("element content")))),
  ]))
);
let mut context = ContextBuilder::new()
   .result_document(RNode::new_document())
   .build();
let mut static_context = StaticContextBuilder::new()
   .message(|m| {message = String::from(m); Ok(())})
   .fetcher(|_| Ok(String::new()))
   .parser(|_| Err(Error::new(ErrorKind::NotImplemented, "not implemented")))
   .build();
let sequence = context.dispatch(&mut static_context, &xform).expect("evaluation failed");

assert_eq!(sequence.to_xml(), "<Example>element content</Example>");
assert_eq!(message, "a message from the transformation")

Implementations

impl<N: Node, F, G, H> StaticContextBuilder<N, F, G, H>

where F: FnMut(&str) -> Result<(), Error>, G: FnMut(&str) -> Result<N, Error>, H: FnMut(&Url) -> Result<String, Error>,

pub fn new() -> Self

pub fn message(self, f: F) -> Self

pub fn parser(self, p: G) -> Self

pub fn fetcher(self, f: H) -> Self

pub fn build(self) -> StaticContext<N, F, G, H>