yao 0.1.4

a fast, tiny, extensiable workflow engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use crate::{env::Enviroment, ActError, ActResult, ActValue, Context, ShareLock, Vars};
use std::{
    collections::HashMap,
    sync::{Arc, RwLock},
};

#[derive(Default, Clone)]
pub struct VirtualMachine {
    env: Arc<Enviroment>,
    pub(crate) scope: ShareLock<rhai::Scope<'static>>,
    pub(crate) vars: ShareLock<Vars>,
}

impl VirtualMachine {
    pub fn new(env: &Enviroment) -> Self {
        let scope = rhai::Scope::new();

        let vm = Self {
            env: Arc::new(env.clone()),
            scope: Arc::new(RwLock::new(scope)),
            vars: Arc::new(RwLock::new(HashMap::new())),
        };

        vm.scope.write().unwrap().set_or_push("env", vm.clone());

        vm
    }

    pub fn init(&self, _ctx: &Context) {}

    pub fn vars(&self) -> Vars {
        self.vars.read().unwrap().clone()
    }

    pub fn set_scope_var<T: Send + Sync + Clone + 'static>(&self, name: &str, v: &T) {
        self.scope.write().unwrap().set_or_push(name, v.clone());
    }

    pub fn append(&self, vars: Vars) {
        self.vars.write().unwrap().extend(vars);
    }

    pub fn run(&self, script: &str) -> ActResult<bool> {
        match self.env.run(script, self) {
            Ok(..) => Ok(true),
            Err(err) => Err(ActError::ScriptError(format!("{}", err))),
        }
    }

    pub fn eval<T: rhai::Variant + Clone>(&self, expr: &str) -> ActResult<T> {
        match self.env.eval::<T>(expr, self) {
            Ok(ret) => Ok(ret),
            Err(err) => Err(ActError::ScriptError(format!("{}", err))),
        }
    }

    pub fn get(&self, name: &str) -> Option<ActValue> {
        let vars = self.vars.read().unwrap();
        match vars.get(name) {
            Some(v) => Some(v.clone()),
            None => None,
        }
    }

    pub fn set(&self, name: &str, value: ActValue) {
        let mut vars = self.vars.write().unwrap();
        vars.entry(name.to_string())
            .and_modify(|i| *i = value.clone())
            .or_insert(value);
    }
}