Graph refactor

components/graph/Cargo.toml

@@ -6,6 +6,7 @@ version = "0.1.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+bevy_shapefile = {path = "../bevy_shapefile"}
 bincode = "1.3.3"
 itertools = "*"
 rayon = "1.5.1"

components/graph/src/dijkstra_iterator.rs

@@ -1,21 +1,19 @@
-use crate::{
-    Backward, DirectedNetworkGraph, EdgeId, Forward, NetworkData, NetworkEdge, NodeId, F32,
-};
+use crate::{Backward, DirectedNetworkGraph, EdgeId, Forward, NetworkEdge, NodeId, F32};
 use std::{
     cmp::Reverse,
     collections::{BinaryHeap, HashSet},
 };
 
-pub struct DijkstraIterator<'a, T: DijkstraDirection, D: NetworkData> {
-    pub network: &'a DirectedNetworkGraph<D>,
+pub struct DijkstraIterator<'a, T: DijkstraDirection> {
+    pub network: &'a DirectedNetworkGraph,
     pub distance: f32,
     pub visited: HashSet<NodeId>,
     pub heap: BinaryHeap<Reverse<(F32, NodeId)>>,
     _marker: std::marker::PhantomData<T>,
 }
 
-impl<'a, T: DijkstraDirection, D: NetworkData> DijkstraIterator<'a, T, D> {
-    pub fn new(network: &'a DirectedNetworkGraph<D>, start: NodeId) -> Self {
+impl<'a, T: DijkstraDirection> DijkstraIterator<'a, T> {
+    pub fn new(network: &'a DirectedNetworkGraph, start: NodeId) -> Self {
         let mut heap = BinaryHeap::new();
         heap.push(Reverse((F32(0.0), start)));
 
@@ -29,10 +27,9 @@ impl<'a, T: DijkstraDirection, D: NetworkData> DijkstraIterator<'a, T, D> {
     }
 }
 
-impl<'a, T, D> Iterator for DijkstraIterator<'a, T, D>
+impl<'a, T> Iterator for DijkstraIterator<'a, T>
 where
     T: DijkstraDirection,
-    D: NetworkData,
 {
     type Item = (NodeId, f32);
 
@@ -43,7 +40,7 @@ where
             }
             for (_, edge) in T::edges(self.network, node) {
                 let target = edge.target();
-                let edge_distance = edge.distance();
+                let edge_distance = edge.weight();
 
                 self.heap
                     .push(Reverse((F32(distance + edge_distance), target)));
@@ -58,24 +55,24 @@ where
 }
 
 pub trait DijkstraDirection {
-    fn edges<'a, D: NetworkData>(
-        network: &'a DirectedNetworkGraph<D>,
+    fn edges<'a>(
+        network: &'a DirectedNetworkGraph,
         node: NodeId,
     ) -> impl Iterator<Item = (EdgeId, &'a NetworkEdge)>;
 }
 
 impl DijkstraDirection for Forward {
-    fn edges<'a, D: NetworkData>(
-        network: &'a DirectedNetworkGraph<D>,
+    fn edges<'a>(
+        network: &'a DirectedNetworkGraph,
         node: NodeId,
     ) -> impl Iterator<Item = (EdgeId, &'a NetworkEdge)> {
         network.out_edges(node)
     }
 }
 
 impl DijkstraDirection for Backward {
-    fn edges<'a, D: NetworkData>(
-        network: &'a DirectedNetworkGraph<D>,
+    fn edges<'a>(
+        network: &'a DirectedNetworkGraph,
         node: NodeId,
     ) -> impl Iterator<Item = (EdgeId, &'a NetworkEdge)> {
         network.in_edges(node)

components/graph/src/directed_graph/builder.rs → components/graph/src/directed_adj_graph/builder.rs

@@ -2,24 +2,7 @@ use crate::{DirectedNetworkGraph, NetworkData, NetworkEdge, NetworkNode, NodeId,
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, fmt::Debug, hash::Hash, ops::Neg};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub enum EdgeDirection {
-    Forward,
-    Both,
-    Backward,
-}
-
-impl Neg for EdgeDirection {
-    type Output = EdgeDirection;
 
-    fn neg(self) -> Self::Output {
-        match self {
-            EdgeDirection::Forward => EdgeDirection::Backward,
-            EdgeDirection::Both => EdgeDirection::Both,
-            EdgeDirection::Backward => EdgeDirection::Forward,
-        }
-    }
-}
 
 pub trait NodeBuilder: Hash + PartialEq + Eq {
     type Data: Clone;

components/graph/src/directed_graph/iterators.rs → components/graph/src/directed_adj_graph/iterators.rs

@@ -1,4 +1,4 @@
-use crate::{builder::EdgeDirection, EdgeId, NetworkEdge};
+use crate::{EdgeDirection, EdgeId, NetworkEdge};
 use std::{ops::Range, slice::Iter};
 
 pub struct EdgeIterator<'a> {

components/graph/src/directed_graph/mod.rs → components/graph/src/directed_adj_graph/mod.rs

@@ -1,13 +1,30 @@
-use self::{builder::EdgeDirection, iterators::EdgeIterator};
+use self::iterators::EdgeIterator;
 use crate::{
     dijkstra_iterator::DijkstraIterator, Backward, EdgeId, Forward, Neighbourhood, NodeId,
 };
-pub use node_data::NetworkData;
 use serde::{Deserialize, Serialize};
+use std::ops::Neg;
 
-pub mod builder;
 pub mod iterators;
-pub mod node_data;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub enum EdgeDirection {
+    Forward,
+    Both,
+    Backward,
+}
+
+impl Neg for EdgeDirection {
+    type Output = EdgeDirection;
+
+    fn neg(self) -> Self::Output {
+        match self {
+            EdgeDirection::Forward => EdgeDirection::Backward,
+            EdgeDirection::Both => EdgeDirection::Both,
+            EdgeDirection::Backward => EdgeDirection::Forward,
+        }
+    }
+}
 
 /// A node in the graph.
 #[derive(Debug, PartialEq, Eq, Clone, Serialize, Deserialize)]
@@ -58,7 +75,7 @@ impl NetworkEdge {
         self.target_node.into()
     }
 
-    pub fn distance(&self) -> f32 {
+    pub fn weight(&self) -> f32 {
         self.edge_weight
     }
 }
@@ -67,29 +84,20 @@ impl NetworkEdge {
 /// It's an adjacency list representation of a graph.
 /// The graph is immutable.
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct DirectedNetworkGraph<D: NetworkData = ()> {
-    pub data: D,
+pub struct DirectedNetworkGraph {
     nodes: Vec<NetworkNode>,
     edges: Vec<NetworkEdge>,
 }
 
-impl<D: NetworkData> DirectedNetworkGraph<D> {
-    pub fn new(nodes: Vec<NetworkNode>, edges: Vec<NetworkEdge>, data: D) -> Self {
-        Self { data, nodes, edges }
+impl DirectedNetworkGraph {
+    pub fn new(nodes: Vec<NetworkNode>, edges: Vec<NetworkEdge>) -> Self {
+        Self { nodes, edges }
     }
 
     pub fn node(&self, node: NodeId) -> &NetworkNode {
         &self.nodes[node.0 as usize]
     }
 
-    pub fn edge_data(&self, edge: EdgeId) -> &D::EdgeData {
-        self.data.edge_data(edge)
-    }
-
-    pub fn node_data(&self, node: NodeId) -> &D::NodeData {
-        self.data.node_data(node)
-    }
-
     pub fn nodes(&self) -> &Vec<NetworkNode> {
         &self.nodes
     }
@@ -133,11 +141,11 @@ impl<D: NetworkData> DirectedNetworkGraph<D> {
         self.create_iterator_raw(node, EdgeDirection::Backward)
     }
 
-    pub fn forward_iterator(&self, node: NodeId) -> DijkstraIterator<'_, Forward, D> {
+    pub fn forward_iterator(&self, node: NodeId) -> DijkstraIterator<'_, Forward> {
         DijkstraIterator::new(self, node)
     }
 
-    pub fn backward_iterator(&self, node: NodeId) -> DijkstraIterator<'_, Backward, D> {
+    pub fn backward_iterator(&self, node: NodeId) -> DijkstraIterator<'_, Backward> {
         DijkstraIterator::new(self, node)
     }
 

components/graph/src/directed_adj_graph/node_data.rs

@@ -0,0 +1,94 @@
+use crate::{EdgeId, NodeId, ShortcutState};
+
+#[derive(Debug)]
+pub struct DefaultNetworkData<N, E> {
+    nodes: Vec<Option<N>>,
+    edges: Vec<Option<E>>,
+    shortcuts: Vec<Option<ShortcutState<EdgeId>>>,
+}
+
+impl<N, E> Default for DefaultNetworkData<N, E> {
+    fn default() -> Self {
+        DefaultNetworkData {
+            nodes: Vec::new(),
+            edges: Vec::new(),
+            shortcuts: Vec::new(),
+        }
+    }
+}
+
+pub trait NetworkData: Send + Sync + Default {
+    type NodeData;
+    type EdgeData;
+    fn node_data(&self, node: NodeId) -> &Self::NodeData;
+    fn edge_data(&self, edge: EdgeId) -> &Self::EdgeData;
+    fn edge_road_id(&self, edge: EdgeId) -> ShortcutState<EdgeId>;
+
+    fn with_size(node_size: usize, edge_size: usize) -> Self;
+    fn add_node(&mut self, node: NodeId, data: Self::NodeData);
+    fn add_edge(&mut self, edge: EdgeId, data: Self::EdgeData, road_id: ShortcutState<EdgeId>);
+}
+
+impl NetworkData for () {
+    type NodeData = ();
+    type EdgeData = ();
+
+    fn node_data(&self, _: NodeId) -> &Self::NodeData {
+        &()
+    }
+
+    fn edge_data(&self, _: EdgeId) -> &Self::EdgeData {
+        &()
+    }
+
+    fn edge_road_id(&self, edge: EdgeId) -> ShortcutState<EdgeId> {
+        ShortcutState::Single(edge)
+    }
+
+    fn add_node(&mut self, _: NodeId, _: Self::NodeData) {}
+
+    fn add_edge(&mut self, _: EdgeId, _: Self::EdgeData, _: ShortcutState<EdgeId>) {}
+
+    fn with_size(_: usize, _: usize) -> Self {
+        ()
+    }
+}
+
+impl<N, E> NetworkData for DefaultNetworkData<N, E>
+where
+    N: Send + Sync + Clone,
+    E: Send + Sync + Clone,
+{
+    type NodeData = N;
+
+    type EdgeData = E;
+
+    fn node_data(&self, node: NodeId) -> &Self::NodeData {
+        self.nodes[node.0 as usize].as_ref().unwrap()
+    }
+
+    fn edge_data(&self, edge: EdgeId) -> &Self::EdgeData {
+        self.edges[edge.0 as usize].as_ref().unwrap()
+    }
+
+    fn edge_road_id(&self, edge: EdgeId) -> ShortcutState<EdgeId> {
+        self.shortcuts[edge.0 as usize].clone().unwrap()
+    }
+
+    fn with_size(node_size: usize, edge_size: usize) -> Self {
+        DefaultNetworkData {
+            nodes: vec![None; node_size],
+            edges: vec![None; edge_size],
+            shortcuts: vec![None; edge_size],
+        }
+    }
+
+    fn add_node(&mut self, node: NodeId, data: Self::NodeData) {
+        self.nodes[node.0 as usize] = Some(data);
+    }
+
+    fn add_edge(&mut self, edge: EdgeId, data: Self::EdgeData, road_id: ShortcutState<EdgeId>) {
+        self.edges[edge.0 as usize] = Some(data);
+        self.shortcuts[edge.0 as usize] = Some(road_id);
+    }
+}