pathfinding-indexed 4.15.0

Index-only pathfinding, flow, and graph algorithms
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

#![doc(hidden)]

use rustc_hash::FxHashSet;
use std::hash::Hash;
use std::iter::FromIterator;
use std::ops::Deref;

/// A set of node references.
///
/// Can be created from a single node reference or an iterable of
/// node references.
///
/// ```rust,ignore
/// use pathfinding_indexed::noderefs::NodeRefs;
///
/// #[derive(Debug, Clone, PartialEq, Eq, Hash)]
/// struct N(String);
///
/// let red = N("red".into());
/// let blue = N("blue".into());
/// let green = N("green".into());
///
/// let refs: NodeRefs<N> = NodeRefs::from(&red);
/// let refs: NodeRefs<N> = NodeRefs::from_iter([&red, &blue, &green]);
/// ```
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NodeRefs<'a, N>(FxHashSet<&'a N>)
where
    N: Eq + Hash + Clone;

impl<'a, N: Eq + Hash + Clone> FromIterator<&'a N> for NodeRefs<'a, N> {
    fn from_iter<T: IntoIterator<Item = &'a N>>(iter: T) -> Self {
        NodeRefs(FxHashSet::from_iter(iter))
    }
}

impl<'a, N: Eq + Hash + Clone> From<&'a N> for NodeRefs<'a, N> {
    fn from(value: &'a N) -> Self {
        NodeRefs(FxHashSet::from_iter([value]))
    }
}

impl<'a, N: Eq + Hash + Clone> IntoIterator for NodeRefs<'a, N> {
    type Item = &'a N;
    type IntoIter = std::collections::hash_set::IntoIter<&'a N>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter()
    }
}

impl<'a, N: Eq + Hash + Clone> IntoIterator for &'a NodeRefs<'a, N> {
    type Item = &'a N;
    type IntoIter = std::iter::Copied<std::collections::hash_set::Iter<'a, &'a N>>;

    fn into_iter(self) -> Self::IntoIter {
        self.0.iter().copied()
    }
}

impl<'a, N: Eq + Hash + Clone> Deref for NodeRefs<'a, N> {
    type Target = FxHashSet<&'a N>;

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

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

    #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
    struct Node(u8);

    #[test]
    fn test_from_iterator() {
        let nodes = [Node(1), Node(2), Node(3)];
        let refs = NodeRefs::from_iter(&nodes);
        assert_eq!(
            refs.0,
            FxHashSet::from_iter([&nodes[0], &nodes[1], &nodes[2]])
        );
    }

    #[test]
    fn test_from_single_ref() {
        let node = Node(42);
        let refs = NodeRefs::from(&node);
        assert_eq!(refs.0, FxHashSet::from_iter([&node]));
    }

    #[test]
    fn test_into_iterator() {
        let nodes = [Node(1), Node(2), Node(3)];
        let refs = NodeRefs::from_iter(&nodes);

        let v = refs.into_iter().sorted().collect::<Vec<_>>();
        assert_eq!(v, vec![&nodes[0], &nodes[1], &nodes[2]]);
    }

    #[test]
    fn test_ref_into_iterator() {
        let nodes = [Node(1), Node(2), Node(3)];
        let refs = NodeRefs::from_iter(&nodes);

        let v = (&refs).into_iter().sorted().collect::<Vec<_>>();
        assert_eq!(v, vec![&nodes[0], &nodes[1], &nodes[2]]);
    }
}