dijkstra-suite 0.1.0-beta.3

A Dijkstra's algorithm implementation that aims to be simple to use and fast to run
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! This modules defines types and traits for a graph
//!
//! ## The`Graph` type
//!
//! The `Graph` type is the other cornerstone of the suite, in pair with `Node` type
//!
//! This type implements the concrete graph representation upon which the dijkstra
//! implementeation will run to compute the shortest path
//!
//! ```rust
//! use std::collections::HashMap;
//! use dijkstra_suite::node::Node;
//! use dijkstra_suite::graph::Graph;
//!
//! let mut graph: Graph<i32, i32> = Graph(HashMap::new());
//!
//! let node_a: Node<i32, i32> = Node::default();
//!
//! graph.insert(0, node_a);
//!
//! let first_node = graph.get(&0).unwrap();
//!
//! assert_eq!(first_node.id, 0)
//! ```

use std::{
    collections::HashMap,
    ops::{Deref, DerefMut},
};

use crate::node::{Node, NodeId, NodeWeight};

#[derive(Debug)]
pub struct Graph<I: NodeId, W: NodeWeight>(pub HashMap<I, Node<I, W>>);

impl<I: NodeId, W: NodeWeight> Default for Graph<I, W> {
    fn default() -> Self {
        Graph(HashMap::new())
    }
}

impl<I: NodeId, W: NodeWeight> Deref for Graph<I, W> {
    type Target = HashMap<I, Node<I, W>>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<I: NodeId, W: NodeWeight> DerefMut for Graph<I, W> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl<I: NodeId, W: NodeWeight> PartialEq for Graph<I, W> {
    fn eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl<I: NodeId, W: NodeWeight> Graph<I, W> {
    pub fn shortest_path(self) -> Vec<I> {
        //

        vec![]
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_graph() {
        // let mut graph: Graph<i32, i32> = Graph(HashMap::new());
        let mut graph: Graph<i32, i32> = Graph::default();

        let node_a: Node<i32, i32> = Node::default();

        graph.insert(0, node_a);

        let first_node = graph.get(&0).unwrap();

        assert_eq!(first_node.id, 0)
    }
}