use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GraphNode {
pub id: String,
pub embedding: Vec<f64>,
pub node_type: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct GraphEdge {
pub from: String,
pub to: String,
pub edge_type: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Graph {
pub nodes: HashMap<String, GraphNode>,
pub edges: HashSet<GraphEdge>,
}
impl Graph {
pub fn empty() -> Self {
Graph {
nodes: HashMap::new(),
edges: HashSet::new(),
}
}
pub fn seed(node: GraphNode) -> Self {
let mut g = Graph::empty();
g.nodes.insert(node.id.clone(), node);
g
}
pub fn node_count(&self) -> usize {
self.nodes.len()
}
pub fn edge_count(&self) -> usize {
self.edges.len()
}
pub fn size(&self) -> usize {
self.node_count() + self.edge_count()
}
pub fn ok(&self, latent_dim: usize) -> bool {
for edge in &self.edges {
if !self.nodes.contains_key(&edge.from) || !self.nodes.contains_key(&edge.to) {
return false;
}
}
for node in self.nodes.values() {
if node.embedding.len() != latent_dim {
return false;
}
for &v in &node.embedding {
if !v.is_finite() {
return false;
}
}
}
true
}
pub fn add_node(&mut self, id: String, embedding: Vec<f64>, node_type: Option<String>) {
self.nodes.insert(
id.clone(),
GraphNode {
id,
embedding,
node_type,
},
);
}
pub fn delete_node(&mut self, id: &str) {
self.nodes.remove(id);
self.edges.retain(|e| e.from != id && e.to != id);
}
pub fn add_edge(&mut self, from: String, to: String, edge_type: String) -> bool {
if !self.nodes.contains_key(&from) || !self.nodes.contains_key(&to) {
return false;
}
self.edges.insert(GraphEdge {
from,
to,
edge_type,
});
true
}
pub fn delete_edge(&mut self, from: &str, to: &str, edge_type: &str) -> bool {
self.edges.remove(&GraphEdge {
from: from.to_string(),
to: to.to_string(),
edge_type: edge_type.to_string(),
})
}
pub fn relabel_node(&mut self, id: &str, new_embedding: Vec<f64>) -> bool {
if let Some(node) = self.nodes.get_mut(id) {
node.embedding = new_embedding;
true
} else {
false
}
}
pub fn rebuild(&mut self, target: &Graph) {
self.nodes = target.nodes.clone();
self.edges = target.edges.clone();
}
pub fn get_embedding(&self, id: &str) -> Option<&Vec<f64>> {
self.nodes.get(id).map(|n| &n.embedding)
}
}
impl Default for Graph {
fn default() -> Self {
Graph::empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn test_graph() -> Graph {
let mut g = Graph::empty();
g.add_node("n1".into(), vec![1.0, 0.0], None);
g.add_node("n2".into(), vec![0.0, 1.0], None);
g.add_edge("n1".into(), "n2".into(), "morph".into());
g
}
#[test]
fn graph_ok_valid() {
let g = test_graph();
assert!(g.ok(2));
}
#[test]
fn graph_ok_wrong_dim() {
let g = test_graph();
assert!(!g.ok(3));
}
#[test]
fn graph_ok_dangling_edge() {
let mut g = test_graph();
g.edges.insert(GraphEdge {
from: "n1".into(),
to: "ghost".into(),
edge_type: "morph".into(),
});
assert!(!g.ok(2));
}
}