stainless_script 0.1.2

Visual node-based programming language
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use crate::{
    class::Class,
    node::Node,
    socket::{InputSocket, OutputSocket},
    ExecutionContext,
};
use std::{borrow::Cow, rc::Rc};

use super::{any_class, string_class};

pub fn variable_get_class() -> Class {
    Class {
        name: "variable_get".into(),
        nodes: vec![Rc::new(VariableGet) as Rc<dyn Node>],
        obj_from_str: None,
    }
}

pub fn variable_set_class() -> Class {
    Class {
        name: "variable_set".into(),
        nodes: vec![],
        obj_from_str: None,
    }
}

#[derive(Debug, Clone)]
pub struct VariableGet;

impl Node for VariableGet {
    fn execute(&self, context: &mut ExecutionContext) -> usize {
        let inputs = context.get_inputs();
        context.set_outputs(
            inputs
                .get(0)
                .and_then(|name| context.get_variable(&name.as_string()))
                .into_iter()
                .collect(),
        );
        0
    }

    fn class(&self) -> Class {
        variable_get_class()
    }

    fn variants(&self) -> Vec<Cow<'_, str>> {
        vec!["get".into()]
    }

    fn current_variant(&self) -> Cow<'_, str> {
        "get".into()
    }

    fn set_variant(&mut self, _variant: &str) {}

    fn inputs(&self) -> Vec<InputSocket> {
        vec![InputSocket {
            class: string_class(),
        }]
    }

    fn outputs(&self) -> Vec<OutputSocket> {
        vec![OutputSocket { class: any_class() }]
    }

    fn clone_node(&self) -> Rc<dyn Node> {
        Rc::new(self.clone()) as Rc<dyn Node>
    }
}

#[derive(Debug, Clone)]
pub struct VariableSet;

impl Node for VariableSet {
    fn execute(&self, context: &mut ExecutionContext) -> usize {
        let inputs = context.get_inputs();
        let name = inputs[0].as_string();
        let value = &inputs[1];
        context.set_variable(&name, Rc::clone(value));
        0
    }

    fn class(&self) -> Class {
        variable_set_class()
    }

    fn variants(&self) -> Vec<Cow<'_, str>> {
        vec!["set".into()]
    }

    fn current_variant(&self) -> Cow<'_, str> {
        "set".into()
    }

    fn set_variant(&mut self, _variant: &str) {}

    fn inputs(&self) -> Vec<InputSocket> {
        vec![
            InputSocket {
                class: string_class(),
            },
            InputSocket { class: any_class() },
        ]
    }

    fn outputs(&self) -> Vec<OutputSocket> {
        vec![]
    }

    fn clone_node(&self) -> Rc<dyn Node> {
        Rc::new(self.clone()) as Rc<dyn Node>
    }
}