graphrs 0.7.0

graphrs is a Rust package for the creation, manipulation and analysis of graphs.
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::cmp::Ordering;
use std::fmt;
use std::fmt::{Debug, Display};
use std::hash::{Hash, Hasher};

/**
Represents a graph node, with `name` and `attributes`.
*/
#[derive(Clone)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct Node<T: Send, A> {
    pub name: T,
    pub attributes: Option<A>,
}

impl<T, A> Node<T, A>
where
    T: Eq + Clone + PartialOrd + Ord + Hash + Send + Sync + Display,
    A: Clone,
{
    /**
    Returns a `Node` with the specified `name` and no attributes.

    # Arguments

    `name`: The name of the node.

    # Examples

    ```
    use graphrs::Node;
    let node = Node::<&str, ()>::from_name("n1");
    ```
    */
    pub fn from_name(name: T) -> Node<T, A> {
        Node {
            name,
            attributes: None,
        }
    }

    /**
    Returns a `Node` with the specified `name` and `attributes`.

    # Arguments

    `name`: The name of the node.
    `name`: The attributes for the node.

    # Examples

    ```
    use graphrs::Node;

    #[derive(Clone, Copy)]
    struct Attributes {
        a: i32,
        b: f64
    }

    let node = Node::from_name_and_attributes("n1", Attributes {a: 3, b: 4.5});
    ```
    */
    pub fn from_name_and_attributes(name: T, attributes: A) -> Node<T, A>
    where
        T: Hash + Eq + Clone,
    {
        Node {
            name,
            attributes: Some(attributes),
        }
    }
}

impl<T: Eq + Ord + Send + Sync, A> Ord for Node<T, A> {
    fn cmp(&self, other: &Self) -> Ordering {
        self.name.cmp(&other.name)
    }
}

impl<T: Eq + PartialOrd + Ord + Send + Sync, A> PartialOrd for Node<T, A> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl<T: std::cmp::PartialEq + Send + Sync, A> PartialEq for Node<T, A> {
    fn eq(&self, other: &Self) -> bool {
        self.name == other.name
    }
}

impl<T: Eq + Send + Sync, A> Eq for Node<T, A> {}

impl<T: Debug + Send + Sync, A> fmt::Debug for Node<T, A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Node").field("name", &self.name).finish()
    }
}

impl<T: Display + Send + Sync, A> fmt::Display for Node<T, A> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.name)
    }
}

impl<T: Hash + Send + Sync, A> Hash for Node<T, A> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.name.hash(state);
    }
}