1use crate::Guid;
2use core::{
3 prefab::{Prefab, PrefabValue},
4 Scalar,
5};
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8
9#[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
10pub enum Reference {
11 None,
12 Named(String),
13 Guid(Guid),
14}
15
16impl Default for Reference {
17 fn default() -> Self {
18 Self::None
19 }
20}
21
22#[derive(Debug, Default, Clone, Serialize, Deserialize)]
23pub struct Program {
24 pub version: usize,
25 #[serde(default)]
26 pub name: String,
27 #[serde(default)]
28 pub types: Vec<Type>,
29 #[serde(default)]
30 pub traits: Vec<Trait>,
31 #[serde(default)]
32 pub functions: Vec<Function>,
33 #[serde(default)]
34 pub events: Vec<Event>,
35 #[serde(default)]
36 pub variables: Vec<Variable>,
37 #[serde(default)]
38 pub operations: Vec<Operation>,
39}
40
41impl Prefab for Program {}
42
43#[derive(Debug, Default, Clone, Serialize, Deserialize)]
44pub struct Event {
45 pub name: String,
46 #[serde(default)]
47 pub input_constrains: Vec<TypeConstraint>,
48 #[serde(default)]
49 pub output_constrains: Vec<TypeConstraint>,
50 #[serde(default)]
51 pub variables: Vec<Variable>,
52 pub nodes: Vec<Node>,
53}
54
55impl Prefab for Event {}
56
57#[derive(Debug, Default, Clone, Serialize, Deserialize)]
58pub struct Variable {
59 pub name: String,
60 pub type_name: String,
61}
62
63impl Prefab for Variable {}
64
65#[derive(Debug, Default, Clone, Serialize, Deserialize)]
66pub struct Type {
67 pub name: String,
68 #[serde(default)]
69 pub fields: Vec<Field>,
70 #[serde(default)]
71 pub traits_implementation: HashMap<String, Vec<Method>>,
72 #[serde(default)]
73 pub export: bool,
74}
75
76impl Prefab for Type {}
77
78#[derive(Debug, Default, Clone, Serialize, Deserialize)]
79pub struct Field {
80 pub name: String,
81 pub type_name: String,
82 #[serde(default)]
83 pub public: bool,
84}
85
86impl Prefab for Field {}
87
88#[derive(Debug, Default, Clone, Serialize, Deserialize)]
89pub struct Trait {
90 pub name: String,
91 #[serde(default)]
92 pub methods: Vec<Method>,
93 #[serde(default)]
94 pub export: bool,
95}
96
97impl Prefab for Trait {}
98
99#[derive(Debug, Default, Clone, Serialize, Deserialize)]
100pub struct Method {
101 pub name: String,
102 pub owner_trait: Reference,
103 #[serde(default)]
104 pub input_constrains: Vec<TypeConstraint>,
105 #[serde(default)]
106 pub output_constrains: Vec<TypeConstraint>,
107 #[serde(default)]
108 pub variables: Vec<Variable>,
109 #[serde(default)]
110 pub associated: bool,
111 #[serde(default)]
112 pub nodes: Vec<Node>,
113 #[serde(default)]
114 pub public: bool,
115 #[serde(default)]
116 pub help: String,
117}
118
119impl Prefab for Method {}
120
121#[derive(Debug, Clone, Serialize, Deserialize)]
122pub enum TypeConstraint {
123 Any,
124 Type(Reference),
125 ImplementTraits(Vec<Reference>),
126 Node,
127}
128
129impl Prefab for TypeConstraint {}
130
131impl Default for TypeConstraint {
132 fn default() -> Self {
133 Self::Any
134 }
135}
136
137#[derive(Debug, Default, Clone, Serialize, Deserialize)]
138pub struct Operation {
139 pub name: String,
140 #[serde(default)]
141 pub input_constrains: Vec<TypeConstraint>,
142 #[serde(default)]
143 pub output_constrains: Vec<TypeConstraint>,
144 #[serde(default)]
145 pub help: String,
146}
147
148impl Prefab for Operation {}
149
150#[derive(Debug, Default, Clone, Serialize, Deserialize)]
151pub struct Function {
152 pub name: String,
153 #[serde(default)]
154 pub input_constrains: Vec<TypeConstraint>,
155 #[serde(default)]
156 pub output_constrains: Vec<TypeConstraint>,
157 #[serde(default)]
158 pub variables: Vec<Variable>,
159 pub nodes: Vec<Node>,
160 #[serde(default)]
161 pub help: String,
162}
163
164impl Prefab for Function {}
165
166#[derive(Debug, Clone, Serialize, Deserialize)]
167pub enum Link {
168 None,
169 NodeIndexed(Reference, usize),
170}
171
172impl Prefab for Link {}
173
174impl Default for Link {
175 fn default() -> Self {
176 Self::None
177 }
178}
179
180#[derive(Debug, Default, Clone, Serialize, Deserialize)]
181pub struct Node {
182 pub id: Reference,
183 pub node_type: NodeType,
184 #[serde(default)]
185 pub next_node: Reference,
186 #[serde(default)]
187 pub input_links: Vec<Link>,
188 #[serde(default)]
189 pub x: Scalar,
190 #[serde(default)]
191 pub y: Scalar,
192}
193
194impl Prefab for Node {}
195
196#[derive(Debug, Default, Clone, Serialize, Deserialize)]
197pub struct IfElse {
198 #[serde(default)]
199 pub next_node_true: Reference,
200 #[serde(default)]
201 pub next_node_false: Reference,
202}
203
204impl Prefab for IfElse {}
205
206#[derive(Debug, Clone, Serialize, Deserialize)]
207pub enum NodeType {
208 None,
209 Entry,
210 Knot,
211 Halt,
212 Loop(Reference),
214 IfElse(IfElse),
215 Break,
216 Continue,
217 GetInstance,
218 GetGlobalVariable(String),
219 GetLocalVariable(String),
220 GetInput(usize),
221 SetOutput(usize),
222 GetValue(Value),
223 GetListItem(usize),
224 GetObjectItem(String),
225 MutateValue,
226 CallOperation(String),
227 CallFunction(String),
228 CallMethod(String, String),
230}
231
232impl NodeType {
233 pub fn is_entry(&self) -> bool {
234 matches!(self, Self::Entry)
235 }
236
237 pub fn is_input_output_flow_in_out(&self) -> (bool, bool, bool, bool) {
238 match self {
239 Self::None => (false, false, false, false),
240 Self::Entry => (false, false, false, true),
241 Self::Knot => (false, false, true, true),
242 Self::Halt => (false, false, true, true),
243 Self::Loop(_) => (false, false, true, true),
244 Self::IfElse(_) => (true, false, true, true),
245 Self::Break => (false, false, true, false),
246 Self::Continue => (false, false, true, false),
247 Self::GetInstance => (false, true, false, true),
248 Self::GetGlobalVariable(_) => (false, true, false, true),
249 Self::GetLocalVariable(_) => (false, true, false, true),
250 Self::GetInput(_) => (false, true, false, true),
251 Self::SetOutput(_) => (true, false, true, true),
252 Self::GetValue(_) => (false, true, false, true),
253 Self::GetListItem(_) => (true, true, true, true),
254 Self::GetObjectItem(_) => (true, true, true, true),
255 Self::MutateValue => (true, false, true, true),
256 Self::CallOperation(_) => (true, true, true, true),
257 Self::CallFunction(_) => (true, true, true, true),
258 Self::CallMethod(_, _) => (true, true, true, true),
259 }
260 }
261}
262
263impl Prefab for NodeType {}
264
265impl Default for NodeType {
266 fn default() -> Self {
267 Self::None
268 }
269}
270
271#[derive(Debug, Clone, Serialize, Deserialize)]
272pub struct Value {
273 pub type_name: String,
274 pub data: PrefabValue,
275}
276
277impl Prefab for Value {}