feat: started working on context and a function registry

Author: raphael-goetz

src/context/mod.rs

@@ -0,0 +1,48 @@
+/// A simple context that holds variable bindings in nested layers.
+/// Each layer is a map from String identifiers to Values.
+use std::collections::HashMap;
+use tucana::shared::{ReferenceValue, Value};
+
+use crate::error::RuntimeError;
+
+#[derive(Debug)]
+pub struct ContextReference {
+    pub primary_level: i32,
+    pub secondary_level: i32,
+    pub tertiary_level: Option<i32>,
+}
+
+#[derive(Debug)]
+pub struct Context {
+    /// A stack of environments: layer 0 is the outermost.
+    layers: HashMap<ContextReference, Result<Value, RuntimeError>>,
+}
+
+impl Context {
+    /// Create a new, empty context.
+    pub fn new() -> Self {
+        Context {
+            layers: HashMap::new(),
+        }
+    }
+
+    /// Look up a name, searching from innermost outward.
+    pub fn get(&self, reference: &ReferenceValue) -> Option<&Result<Value, RuntimeError>> {
+        for (context, value) in self.layers.iter() {
+            if context.primary_level != reference.primary_level {
+                continue;
+            }
+
+            if context.secondary_level != reference.secondary_level {
+                continue;
+            }
+
+            if context.tertiary_level != reference.tertiary_level {
+                continue;
+            }
+
+            return Some(value);
+        }
+        None
+    }
+}

src/error/mod.rs

@@ -0,0 +1,15 @@
+use std::{
+    error::Error,
+    fmt::{Display, Formatter},
+};
+
+#[derive(Debug)]
+pub struct RuntimeError {}
+
+impl Error for RuntimeError {}
+
+impl Display for RuntimeError {
+    fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
+        write!(f, "&self.function_name.as_str()")
+    }
+}

src/main.rs

@@ -1,3 +1,6 @@
+pub mod context;
+pub mod error;
+pub mod registry;
 use code0_flow::flow_queue::service::{Message, RabbitmqClient};
 use std::sync::Arc;
 

src/registry/mod.rs

@@ -0,0 +1,31 @@
+use crate::{context::Context, error::RuntimeError};
+use std::collections::HashMap;
+use tucana::shared::Value;
+
+pub type HandlerFn = fn(&[Value], &mut Context) -> Result<Value, RuntimeError>;
+
+/// Holds all registered handlers.
+pub struct FunctionStore {
+    functions: HashMap<String, HandlerFn>,
+}
+
+impl FunctionStore {
+    /// Create a new, empty store.
+    pub fn new() -> Self {
+        FunctionStore {
+            functions: HashMap::new(),
+        }
+    }
+
+    /// Look up a handler by its ID.
+    pub fn get(&self, id: &str) -> Option<&HandlerFn> {
+        self.functions.get(id)
+    }
+
+    /// Execute all the registration closures to populate the map.
+    fn populate(&mut self, regs: Vec<(&'static str, HandlerFn)>) {
+        for (id, func) in regs {
+            self.functions.insert(id.to_string(), func);
+        }
+    }
+}