relrc 0.5.0

Reference counted pointers, with relationships to other pointers.
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
112
113

//! Implementation of the [`petgraph`] graph traits

mod edge_ref;
use std::collections::HashSet;

pub use edge_ref::EdgeRef;

use petgraph::{
    visit::{
        Data, GraphBase, GraphRef, IntoEdgeReferences, IntoEdges, IntoEdgesDirected, IntoNeighbors,
        IntoNeighborsDirected, IntoNodeIdentifiers, Visitable,
    },
    Direction,
};

use crate::{EdgeId, HistoryGraph, NodeId};

impl<'a, N, E> GraphBase for &'a HistoryGraph<N, E> {
    type EdgeId = EdgeId;
    type NodeId = NodeId;
}

impl<'a, N, E> GraphRef for &'a HistoryGraph<N, E> {}

impl<'a, N, E> IntoNeighbors for &'a HistoryGraph<N, E> {
    type Neighbors = Box<dyn Iterator<Item = Self::NodeId> + 'a>;

    fn neighbors(self, n: Self::NodeId) -> Self::Neighbors {
        self.neighbors_directed(n, Direction::Outgoing)
    }
}

impl<'a, N, E> IntoNeighborsDirected for &'a HistoryGraph<N, E> {
    type NeighborsDirected = Box<dyn Iterator<Item = Self::NodeId> + 'a>;

    fn neighbors_directed(self, node_id: Self::NodeId, d: Direction) -> Self::NeighborsDirected {
        match d {
            Direction::Outgoing => Box::new(self.outgoing_edges(node_id).map(|e| e.target)),
            Direction::Incoming => Box::new(
                self.incoming_edges(node_id)
                    .map(|e| self.source(e).expect("edge is valid")),
            ),
        }
    }
}

impl<'a, N, E> Data for &'a HistoryGraph<N, E> {
    type NodeWeight = N;
    type EdgeWeight = E;
}

impl<'a, N, E> IntoEdgeReferences for &'a HistoryGraph<N, E> {
    type EdgeRef = EdgeRef<'a, N, E>;

    type EdgeReferences = Box<dyn Iterator<Item = Self::EdgeRef> + 'a>;

    fn edge_references(self) -> Self::EdgeReferences {
        Box::new(self.all_node_ids().flat_map(move |node_id| {
            self.incoming_edges(node_id)
                .map(move |edge_id| EdgeRef::new(edge_id, self))
        }))
    }
}

impl<'a, N, E> IntoNodeIdentifiers for &'a HistoryGraph<N, E> {
    type NodeIdentifiers = Box<dyn Iterator<Item = Self::NodeId> + 'a>;

    fn node_identifiers(self) -> Self::NodeIdentifiers {
        Box::new(self.all_node_ids())
    }
}

impl<'a, N, E> IntoEdges for &'a HistoryGraph<N, E> {
    type Edges = Box<dyn Iterator<Item = Self::EdgeRef> + 'a>;

    fn edges(self, node_id: Self::NodeId) -> Self::Edges {
        Box::new(
            self.outgoing_edges(node_id)
                .map(|edge_id| EdgeRef::new(edge_id, self)),
        )
    }
}

impl<'a, N, E> IntoEdgesDirected for &'a HistoryGraph<N, E> {
    type EdgesDirected = Box<dyn Iterator<Item = Self::EdgeRef> + 'a>;

    fn edges_directed(self, node_id: Self::NodeId, d: Direction) -> Self::EdgesDirected {
        match d {
            Direction::Outgoing => Box::new(
                self.outgoing_edges(node_id)
                    .map(|edge_id| EdgeRef::new(edge_id, self)),
            ),
            Direction::Incoming => Box::new(
                self.incoming_edges(node_id)
                    .map(|edge_id| EdgeRef::new(edge_id, self)),
            ),
        }
    }
}

impl<'a, N, E> Visitable for &'a HistoryGraph<N, E> {
    type Map = HashSet<NodeId>;

    #[doc = r" Create a new visitor map"]
    fn visit_map(&self) -> Self::Map {
        HashSet::new()
    }

    #[doc = r" Reset the visitor map (and resize to new size of graph if needed)"]
    fn reset_map(&self, map: &mut Self::Map) {
        map.clear();
    }
}