Struct ConverterBuilder 

pub struct ConverterBuilder<F>
where
    F: Fn(Value) -> DataResult<Value> + Send + Sync + 'static,
{ /* private fields */ }

Builder that turns a closure into a Converter.

use daedalus_data::convert::{ConverterBuilder, ConverterGraph};
use daedalus_data::errors::{DataError, DataErrorCode};
use daedalus_data::model::{TypeExpr, Value, ValueType};

let conv = ConverterBuilder::new(
    "int_to_string",
    TypeExpr::Scalar(ValueType::Int),
    TypeExpr::Scalar(ValueType::String),
    |v| match v {
        Value::Int(i) => Ok(Value::String(i.to_string().into())),
        _ => Err(DataError::new(DataErrorCode::InvalidType, "expected int")),
    },
)
.cost(2u64)
.feature_flag("fmt")
.build_boxed();

let mut graph = ConverterGraph::new();
graph.register(conv);
let res = graph
    .resolve_with_context(
        &TypeExpr::Scalar(ValueType::Int),
        &TypeExpr::Scalar(ValueType::String),
        &["fmt".into()],
        true,
    )
    .expect("resolution");
assert_eq!(res.provenance.steps.len(), 1);

Implementations

impl<F> ConverterBuilder<F>

where F: Fn(Value) -> DataResult<Value> + Send + Sync + 'static,

pub fn new( id: impl Into<String>, input: TypeExpr, output: TypeExpr, func: F, ) -> Self

pub fn cost(self, cost: u64) -> Self

pub fn feature_flag(self, flag: impl Into<String>) -> Self

pub fn requires_gpu(self, requires: bool) -> Self

pub fn build(self) -> FnConverter<F>

pub fn build_boxed(self) -> Box<dyn Converter>