Updated CausaloidGraph with proper internal index structure and proper error handling.

Author: marvin-hansen

deep_causality/src/errors/mod.rs

@@ -40,6 +40,18 @@ impl fmt::Display for ContextIndexError
     }
 }
 
+#[derive(Debug)]
+pub struct CausalGraphIndexError(pub String);
+
+impl Error for CausalGraphIndexError {}
+
+impl fmt::Display for CausalGraphIndexError
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "CausalGraphIndexError: {}", self.0)
+    }
+}
+
 #[derive(Debug)]
 pub struct CausalityError(pub String);
 

deep_causality/src/prelude.rs

@@ -6,10 +6,7 @@ pub use crate::csm::csm_state::CausalState;
 pub use crate::csm::CSM;
 //
 // Error
-pub use crate::errors::ActionError;
-pub use crate::errors::BuildError;
-pub use crate::errors::CausalityError;
-pub use crate::errors::CausalityGraphError;
+pub use crate::errors::*;
 //
 // Extensions
 pub use crate::extensions::assumable::*;

deep_causality/src/protocols/causable_graph/mod.rs

@@ -1,31 +1,32 @@
 // Copyright (c) "2023" . Marvin Hansen <[email protected]> All rights reserved.
 use std::collections::HashMap;
-use crate::errors::CausalityGraphError;
-use crate::prelude::{Causable, IdentificationValue, NodeIndex, NumericalValue};
+use crate::errors::{CausalGraphIndexError, CausalityGraphError};
+use crate::prelude::{Causable, IdentificationValue, NumericalValue};
 
 pub trait CausableGraph<T>
     where
         T: Causable + PartialEq,
 {
     // Root Node
-    fn add_root_causaloid(&mut self, value: T) -> NodeIndex;
+    fn add_root_causaloid(&mut self, value: T) -> usize;
     fn contains_root_causaloid(&self) -> bool;
     fn get_root_causaloid(&self) -> Option<&T>;
-    fn get_root_index(&self) -> Option<NodeIndex>;
-    fn get_last_index(&self) ->  Result<NodeIndex, CausalityGraphError>;
+    fn get_root_index(&self) -> Option<usize>;
+    fn get_last_index(&self) -> Result<usize, CausalityGraphError>;
 
     // Nodes
-    fn add_causaloid(&mut self, value: T) -> NodeIndex;
-    fn contains_causaloid(&self, index: NodeIndex) -> bool;
-    fn get_causaloid(&self, index: NodeIndex) -> Option<&T>;
-    fn remove_causaloid(&mut self, index: NodeIndex);
+    fn add_causaloid(&mut self, value: T) -> usize;
+    fn contains_causaloid(&self, index: usize) -> bool;
+    fn get_causaloid(&self, index: usize) -> Option<&T>;
+    fn remove_causaloid(&mut self, index: usize) -> Result<(), CausalGraphIndexError>
+    ;
 
     // Edges
-    fn add_edge(&mut self, a: NodeIndex, b: NodeIndex);
-    fn add_edg_with_weight(&mut self, a: NodeIndex, b: NodeIndex, weight: u64);
+    fn add_edge(&mut self, a: usize, b: usize) -> Result<(), CausalGraphIndexError>;
+    fn add_edg_with_weight(&mut self, a: usize, b: usize, weight: u64) -> Result<(), CausalGraphIndexError>;
 
-    fn contains_edge(&self, a: NodeIndex, b: NodeIndex) -> bool;
-    fn remove_edge(&mut self, a: NodeIndex, b: NodeIndex);
+    fn contains_edge(&self, a: usize, b: usize) -> bool;
+    fn remove_edge(&mut self, a: usize, b: usize) -> Result<(), CausalGraphIndexError>;
 
     // Utils
     fn all_active(&self) -> bool;
@@ -60,7 +61,7 @@ pub trait CausableGraphReasoning<T>
     /// Returns: String representing the explanation or an error
     fn explain_subgraph_from_cause(
         &self,
-        start_index: NodeIndex,
+        start_index: usize,
     )
         -> Result<String, CausalityGraphError>;
 
@@ -74,8 +75,8 @@ pub trait CausableGraphReasoning<T>
     /// Returns: String representing the explanation or an error
     fn explain_shortest_path_between_causes(
         &self,
-        start_index: NodeIndex,
-        stop_index: NodeIndex,
+        start_index: usize,
+        stop_index: usize,
     )
         -> Result<String, CausalityGraphError>;
 
@@ -115,7 +116,7 @@ pub trait CausableGraphReasoning<T>
     /// a CausalityGraphError in case of failure.
     fn reason_subgraph_from_cause(
         &self,
-        start_index: NodeIndex,
+        start_index: usize,
         data: &[NumericalValue],
         data_index: Option<&HashMap<IdentificationValue, IdentificationValue>>,
     )
@@ -138,8 +139,8 @@ pub trait CausableGraphReasoning<T>
     /// a CausalityGraphError in case of failure.
     fn reason_shortest_path_between_causes(
         &self,
-        start_index: NodeIndex,
-        stop_index: NodeIndex,
+        start_index: usize,
+        stop_index: usize,
         data: &[NumericalValue],
         data_index: Option<&HashMap<IdentificationValue, IdentificationValue>>,
     )
@@ -153,7 +154,7 @@ pub trait CausableGraphReasoning<T>
     /// a CausalityGraphError in case of failure.
     fn reason_single_cause(
         &self,
-        index: NodeIndex,
+        index: usize,
         data: &[NumericalValue],
     )
         -> Result<bool, CausalityGraphError>;

deep_causality/src/types/context_types/context.rs

@@ -3,9 +3,13 @@
 use std::collections::HashMap;
 use std::fmt::{Debug, Display, Formatter};
 use petgraph::Directed;
+use petgraph::graph::{NodeIndex as GraphNodeIndex};
 use petgraph::matrix_graph::MatrixGraph;
 use crate::errors::ContextIndexError;
-use crate::prelude::{Contextuable, Contextoid, Datable, NodeIndex, SpaceTemporal, Spatial, Temporal, RelationKind, Identifiable};
+use crate::prelude::{Contextuable, Contextoid, Datable, SpaceTemporal, Spatial, Temporal, RelationKind, Identifiable};
+
+type DefaultIx = u32;
+type NodeIndex<Ix = DefaultIx> = GraphNodeIndex<Ix>;
 
 //
 // Edge weights need to be numerical (u64) to make shortest path algo work.
@@ -185,7 +189,7 @@ impl<'l, D, S, T, ST> Contextuable<'l, D, S, T, ST> for Context<'l, D, S, T, ST>
         -> Result<(), ContextIndexError>
     {
         if !self.contains_node(index) {
-            return Err(ContextIndexError("index not found".into()));
+            return Err(ContextIndexError(format!("index {} not found", index)));
         };
 
         let k = self.index_map.get(&index).unwrap();
@@ -209,11 +213,11 @@ impl<'l, D, S, T, ST> Contextuable<'l, D, S, T, ST> for Context<'l, D, S, T, ST>
         -> Result<(), ContextIndexError>
     {
         if !self.contains_node(a) {
-            return Err(ContextIndexError("index a not found".into()));
+            return Err(ContextIndexError(format!("index a {} not found", a)));
         };
 
         if !self.contains_node(b) {
-            return Err(ContextIndexError("index b not found".into()));
+            return Err(ContextIndexError(format!("index b {} not found", b)));
         };
 
         let k = self.index_map.get(&a).expect("index not found");