jsoncanvas/
jsoncanvas.rs

1use std::collections::HashMap;
2use std::fmt::{Display, Formatter};
3use std::str::FromStr;
4
5use crate::edge::Edge;
6use crate::id::EmptyId;
7use crate::node::GenericNodeInfo;
8use crate::node::Node;
9use crate::EdgeId;
10use crate::NodeId;
11
12use serde::{Deserialize, Deserializer, Serialize, Serializer};
13use serde_json;
14use thiserror::Error;
15
16#[derive(Debug, Error)]
17pub enum JsonCanvasError {
18    #[error("Node {0} already exists")]
19    NodeExists(NodeId),
20    #[error("Edge {0} already exists")]
21    EdgeExists(EdgeId),
22    #[error("Node {0} does not exist")]
23    NodeNotExists(NodeId),
24    #[error(transparent)]
25    ParseError(#[from] serde_json::Error),
26    #[error(transparent)]
27    EmptyId(#[from] EmptyId),
28}
29
30/// JsonCanvas
31///
32/// Main struct for the canvas
33///
34#[derive(Debug, Serialize, Deserialize, Default)]
35pub struct JsonCanvas {
36    #[serde(
37        serialize_with = "serialize_as_vec_node",
38        deserialize_with = "deserialize_as_map_node"
39    )]
40    #[serde(skip_serializing_if = "HashMap::is_empty", default)]
41    nodes: HashMap<NodeId, Node>,
42    #[serde(
43        serialize_with = "serialize_as_vec_edge",
44        deserialize_with = "deserialize_as_map_edge"
45    )]
46    #[serde(skip_serializing_if = "HashMap::is_empty", default)]
47    edges: HashMap<EdgeId, Edge>,
48}
49fn serialize_as_vec_node<S>(data: &HashMap<NodeId, Node>, serializer: S) -> Result<S::Ok, S::Error>
50where
51    S: Serializer,
52{
53    let vec: Vec<&Node> = data.values().collect();
54    vec.serialize(serializer)
55}
56
57fn deserialize_as_map_node<'de, D>(deserializer: D) -> Result<HashMap<NodeId, Node>, D::Error>
58where
59    D: Deserializer<'de>,
60{
61    let vec: Vec<Node> = Vec::deserialize(deserializer)?;
62    let map: HashMap<_, _> = vec
63        .into_iter()
64        .map(|node| (node.id().clone(), node))
65        .collect();
66    Ok(map)
67}
68
69fn serialize_as_vec_edge<S>(data: &HashMap<EdgeId, Edge>, serializer: S) -> Result<S::Ok, S::Error>
70where
71    S: Serializer,
72{
73    let vec: Vec<&Edge> = data.values().collect();
74    vec.serialize(serializer)
75}
76
77fn deserialize_as_map_edge<'de, D>(deserializer: D) -> Result<HashMap<EdgeId, Edge>, D::Error>
78where
79    D: Deserializer<'de>,
80{
81    let vec: Vec<Edge> = Vec::deserialize(deserializer)?;
82    let map: HashMap<_, _> = vec
83        .into_iter()
84        .map(|node| (node.id().clone(), node))
85        .collect();
86    Ok(map)
87}
88
89impl JsonCanvas {
90    pub fn add_node(&mut self, node: Node) -> Result<(), JsonCanvasError> {
91        if self.nodes.contains_key(node.id()) {
92            return Err(JsonCanvasError::NodeExists(node.id().clone()));
93        }
94        self.nodes.insert(node.id().clone(), node);
95        Ok(())
96    }
97
98    pub fn add_edge(&mut self, edge: Edge) -> Result<(), JsonCanvasError> {
99        if self.edges.contains_key(edge.id()) {
100            return Err(JsonCanvasError::EdgeExists(edge.id().clone()));
101        }
102
103        if !self.nodes.contains_key(edge.from_node()) {
104            return Err(JsonCanvasError::NodeNotExists(edge.from_node().clone()));
105        }
106
107        if !self.nodes.contains_key(edge.to_node()) {
108            return Err(JsonCanvasError::NodeNotExists(edge.to_node().clone()));
109        }
110
111        self.edges.insert(edge.id().clone(), edge);
112        Ok(())
113    }
114
115    pub fn get_node(&mut self, id: NodeId) -> Option<&mut Node> {
116        self.nodes.get_mut(&id)
117    }
118
119    pub fn get_edge(&mut self, id: EdgeId) -> Option<&mut Edge> {
120        self.edges.get_mut(&id)
121    }
122
123    pub fn get_nodes(&self) -> &HashMap<NodeId, Node> {
124        &self.nodes
125    }
126
127    pub fn get_mut_nodes(&mut self) -> &mut HashMap<NodeId, Node> {
128        &mut self.nodes
129    }
130
131    pub fn get_edges(&self) -> &HashMap<EdgeId, Edge> {
132        &self.edges
133    }
134
135    pub fn get_mut_edges(&mut self) -> &mut HashMap<EdgeId, Edge> {
136        &mut self.edges
137    }
138}
139
140impl FromStr for JsonCanvas {
141    type Err = JsonCanvasError;
142
143    fn from_str(s: &str) -> Result<Self, Self::Err> {
144        Ok(serde_json::from_str(s)?)
145    }
146}
147
148impl Display for JsonCanvas {
149    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
150        write!(f, "{}", serde_json::to_string(self).unwrap())
151    }
152}
jsoncanvas/jsoncanvas.rs

jsoncanvas/
jsoncanvas.rs
