gryf 0.2.1

Graph data structure library with focus on convenience, versatility, correctness and performance.
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

//! Initialization of graphs.

use super::{base::IntoEdge, graph::GraphAdd};

/// Trait for creating a graph with known or estimated capacity.
pub trait Create<V, E>: GraphAdd<V, E> + Sized {
    #[doc = include_str!("../../docs/include/create.with_capacity.md")]
    fn with_capacity(vertex_capacity: usize, edge_capacity: usize) -> Self;

    #[doc = include_str!("../../docs/include/create.empty.md")]
    fn empty() -> Self {
        Self::with_capacity(0, 0)
    }
}

/// Trait for extending graph with or creating graph from an iterator of vertices.
pub trait ExtendWithVertices<V, E>: Create<V, E> {
    #[doc = include_str!("../../docs/include/extend_with_vertices.extend_with_vertices.md")]
    fn extend_with_vertices<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = V>;

    #[doc = include_str!("../../docs/include/extend_with_vertices.from_vertices.md")]
    fn from_vertices<I>(iter: I) -> Self
    where
        I: IntoIterator<Item = V>,
    {
        let iter = iter.into_iter();
        let vertex_count = iter.size_hint().1.unwrap_or(32);

        let mut graph = Self::with_capacity(vertex_count, 0);
        graph.extend_with_vertices(iter);
        graph
    }
}

impl<V, E, G> ExtendWithVertices<V, E> for G
where
    G: Create<V, E>,
{
    fn extend_with_vertices<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = V>,
    {
        for vertex in iter {
            self.add_vertex(vertex);
        }
    }
}

/// Trait for extending graph with an iterator of edges.
pub trait ExtendWithEdges<T, V, E>: Create<V, E>
where
    T: IntoEdge<Self, E>,
{
    #[doc = include_str!("../../docs/include/extend_with_edges.extend_with_edges.md")]
    fn extend_with_edges<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = T>;
}

impl<T, V, E, G> ExtendWithEdges<T, V, E> for G
where
    T: IntoEdge<Self, E>,
    G: Create<V, E>,
{
    fn extend_with_edges<I>(&mut self, iter: I)
    where
        I: IntoIterator<Item = T>,
    {
        for edge in iter {
            let (from, to, edge) = edge.unpack();
            self.add_edge(&from, &to, edge);
        }
    }
}