Backend support for update and uninterpreted functions

src-tauri/Cargo.toml

@@ -10,13 +10,9 @@ edition = "2021"
 [build-dependencies]
 tauri-build = { version = "1.4", features = [] }
 
-[[bin]]
-name = "cli-test"
-path = "src/bin/cli-test.rs"
-
 [dependencies]
-biodivine-lib-bdd = ">=0.5.6, <1.0.0"
-biodivine-lib-param-bn = ">=0.5.0, <1.0.0"
+biodivine-lib-bdd = ">=0.5.11, <1.0.0"
+biodivine-lib-param-bn = ">=0.5.9, <1.0.0"
 lazy_static = "1.4.0"
 regex = "1.10.2"
 tauri = { version = "1.4", features = [ "window-set-focus", "window-set-size", "window-close", "window-create", "dialog-all", "shell-open"] }

src-tauri/src/app/state/editor/_state_editor_session.rs

@@ -197,7 +197,7 @@ impl SessionState for EditorSession {
         } else if let Some(at_path) = Self::starts_with("model", at_path) {
             self.model.perform_event(event, at_path)
         } else {
-            Self::invalid_path_error(at_path)
+            Self::invalid_path_error_generic(at_path)
         }
     }
 
@@ -209,7 +209,7 @@ impl SessionState for EditorSession {
         } else if let Some(at_path) = Self::starts_with("model", at_path) {
             self.model.refresh(full_path, at_path)
         } else {
-            Self::invalid_path_error(at_path)
+            Self::invalid_path_error_generic(at_path)
         }
     }
 }

src-tauri/src/app/state/editor/_state_tab_bar.rs

@@ -17,7 +17,7 @@ impl SessionState for TabBarState {
         } else if let Some(at_path) = Self::starts_with("pinned", at_path) {
             self.pinned.perform_event(event, at_path)
         } else {
-            Self::invalid_path_error(at_path)
+            Self::invalid_path_error_generic(at_path)
         }
     }
 
@@ -27,7 +27,7 @@ impl SessionState for TabBarState {
         } else if let Some(at_path) = Self::starts_with("pinned", at_path) {
             self.pinned.refresh(full_path, at_path)
         } else {
-            Self::invalid_path_error(at_path)
+            Self::invalid_path_error_generic(at_path)
         }
     }
 }

src-tauri/src/app/state/mod.rs

@@ -58,13 +58,52 @@ pub trait SessionHelper {
     }
 
     /// A utility function which emits a generic "invalid path" error.
-    fn invalid_path_error<T>(at_path: &[&str]) -> Result<T, DynError> {
+    fn invalid_path_error_generic<T>(at_path: &[&str]) -> Result<T, DynError> {
         AeonError::throw(format!(
             "`{}` cannot process path `{:?}`.",
             std::any::type_name::<Self>(),
             at_path
         ))
     }
+
+    /// A utility function which emits a "invalid path" error mentioning specific state's `component`.
+    fn invalid_path_error_specific<T>(path: &[&str], component: &str) -> Result<T, DynError> {
+        AeonError::throw(format!("`{component}` cannot process path `{:?}`.", path))
+    }
+
+    /// A utility function to get and clone a payload of an event. Errors if payload is empty.
+    ///
+    /// The `component` specifies which component of the state should be mentioned in the error.
+    /// This might be useful to directly mention relevant fields of more complex types.
+    fn clone_payload_str(event: &Event, component: &str) -> Result<String, DynError> {
+        let payload = event.payload.clone().ok_or(format!(
+            "This event to `{component}` cannot carry empty payload."
+        ))?;
+        Ok(payload)
+    }
+
+    /// A utility function to assert that path has a given length, or emit a `DynError` otherwise.
+    ///
+    /// The `component` specifies the state's component that should be mentioned in the error.
+    /// This might be useful to directly mention relevant fields of more complex types.
+    fn assert_path_length(path: &[&str], length: usize, component: &str) -> Result<(), DynError> {
+        if path.len() != length {
+            return AeonError::throw(format!("`{component}` cannot process path `{:?}`.", path));
+        }
+        Ok(())
+    }
+
+    /// A utility function to assert that payload is empty - otherwise, `DynError` is emitted.
+    ///
+    /// The `component` specifies which component of the state should be mentioned in the error.
+    /// This might be useful to directly mention relevant fields of more complex types.
+    fn assert_payload_empty(event: &Event, component: &str) -> Result<(), DynError> {
+        if event.payload.is_some() {
+            let message = format!("This event to `{component}` cannot have empty payload.");
+            return AeonError::throw(message);
+        }
+        Ok(())
+    }
 }
 
 pub trait Session: SessionState {

src-tauri/src/main.rs

@@ -4,7 +4,7 @@
 use aeon_sketchbook::app::event::{Event, UserAction};
 use aeon_sketchbook::app::state::editor::EditorSession;
 use aeon_sketchbook::app::state::{AppState, DynSession};
-use aeon_sketchbook::app::{AeonApp, AEON_ACTION, AEON_REFRESH};
+use aeon_sketchbook::app::{AeonApp, AEON_ACTION, AEON_REFRESH, AEON_VALUE};
 use aeon_sketchbook::debug;
 use serde::{Deserialize, Serialize};
 use tauri::{command, Manager, State, Window};
@@ -62,7 +62,15 @@ fn main() {
                 let result = state.consume_event(&aeon, session_id.as_str(), &action);
                 if let Err(e) = result {
                     // TODO: This should be a normal error.
-                    panic!("Event error: {:?}", e);
+                    //panic!("Event error: {:?}", e);
+
+                    // TODO: This is only a temporary solution to propagate the error message to frontend.
+                    debug!("Error processing last event: `{}`.", e.to_string());
+                    let json_message = format!("\"{e}\"");
+                    let state_change = Event::build(&["error"], Some(&json_message));
+                    if aeon.tauri.emit_all(AEON_VALUE, vec![state_change]).is_err() {
+                        panic!("Event error failed to be sent: {:?}", e);
+                    }
                 }
             });
             let aeon = aeon_original.clone();

src-tauri/src/sketchbook/_binary_op.rs

@@ -0,0 +1,51 @@
+use biodivine_lib_param_bn::BinaryOp as OtherBinaryOp;
+use core::convert::From;
+use serde::{Deserialize, Serialize};
+use std::fmt::{Display, Error, Formatter};
+
+/// Possible binary Boolean operators that can appear in `FnUpdate`.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
+pub enum BinaryOp {
+    And,
+    Or,
+    Xor,
+    Iff,
+    Imp,
+}
+
+impl From<OtherBinaryOp> for BinaryOp {
+    fn from(value: OtherBinaryOp) -> Self {
+        match value {
+            OtherBinaryOp::And => BinaryOp::And,
+            OtherBinaryOp::Or => BinaryOp::Or,
+            OtherBinaryOp::Xor => BinaryOp::Xor,
+            OtherBinaryOp::Iff => BinaryOp::Iff,
+            OtherBinaryOp::Imp => BinaryOp::Imp,
+        }
+    }
+}
+
+impl Display for BinaryOp {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let symbol = match self {
+            BinaryOp::And => "&",
+            BinaryOp::Or => "|",
+            BinaryOp::Xor => "^",
+            BinaryOp::Imp => "=>",
+            BinaryOp::Iff => "<=>",
+        };
+        write!(f, "{}", symbol)
+    }
+}
+
+impl BinaryOp {
+    pub fn to_lib_param_bn_version(&self) -> OtherBinaryOp {
+        match self {
+            BinaryOp::And => OtherBinaryOp::And,
+            BinaryOp::Or => OtherBinaryOp::Or,
+            BinaryOp::Xor => OtherBinaryOp::Xor,
+            BinaryOp::Iff => OtherBinaryOp::Iff,
+            BinaryOp::Imp => OtherBinaryOp::Imp,
+        }
+    }
+}

src-tauri/src/sketchbook/_observability.rs → src-tauri/src/sketchbook/_essentiality.rs

@@ -1,12 +1,12 @@
 use serde::{Deserialize, Serialize};
 
-/// Possible variants of observability of a `Regulation`.
+/// Possible variants of essentiality of a `Regulation`.
 ///
-/// - `True` means that the regulation is observable and must have an effect
+/// - `True` means that the regulation is essential and must have an effect
 /// - `False` means that it has no effect
 /// - `Unknown` means it might or might not have an effect.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq, Serialize, Deserialize)]
-pub enum Observability {
+pub enum Essentiality {
     True,
     False,
     Unknown,