xot 0.31.2

Full-featured XML tree library for Rust
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

use ahash::HashMap;
use std::borrow::Borrow;
use std::hash::Hash;

pub(crate) trait IdIndex<T> {
    fn to_id(index: usize) -> T;
    fn from_id(id: T) -> usize;
}

#[derive(Debug, Clone)]
pub(crate) struct IdMap<K: Copy + IdIndex<K>, V: Eq + std::hash::Hash + Clone> {
    by_id: Vec<V>,
    by_value: HashMap<V, K>,
}

impl<K: Copy + IdIndex<K>, V: Eq + std::hash::Hash + Clone> IdMap<K, V> {
    pub(crate) fn new() -> Self {
        IdMap {
            by_id: Vec::new(),
            by_value: HashMap::default(),
        }
    }

    pub(crate) fn get_id_mut<Q>(&mut self, value: &Q) -> K
    where
        V: Borrow<Q>,
        Q: Hash + Eq + ToOwned<Owned = V> + ?Sized,
    {
        let id = self.by_value.get(value);
        if let Some(id) = id {
            *id
        } else {
            let id = K::to_id(self.by_id.len());
            let cloned = value.to_owned();
            self.by_value.insert(cloned.clone(), id);
            self.by_id.push(cloned);
            id
        }
    }

    pub(crate) fn get_id<Q>(&self, value: &Q) -> Option<K>
    where
        V: Borrow<Q>,
        Q: Hash + Eq + ?Sized,
    {
        self.by_value.get(value).copied()
    }

    #[inline]
    pub(crate) fn get_value(&self, id: K) -> &V {
        &self.by_id[K::from_id(id)]
    }
}

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

    #[test]
    fn test_id_map() {
        #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
        struct Id(u32);

        impl IdIndex<Id> for Id {
            fn to_id(index: usize) -> Id {
                Id(index as u32)
            }

            fn from_id(id: Id) -> usize {
                id.0 as usize
            }
        }

        let mut map = IdMap::<Id, String>::new();
        let id1 = map.get_id_mut("foo");
        let id2 = map.get_id_mut("bar");
        let id3 = map.get_id_mut("foo");
        assert_eq!(id1, id3);
        assert_ne!(id1, id2);
        assert_eq!(map.get_value(id1), &"foo");
        assert_eq!(map.get_value(id2), &"bar");

        let id4 = map.get_id("foo").unwrap();
        assert_eq!(id1, id4);
    }

    // #[test]
    // fn test_id_map_with_cow() {
    //     use std::borrow::Cow;

    //     #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
    //     struct Id(u32);

    //     impl IdIndex<Id> for Id {
    //         fn to_id(index: usize) -> Id {
    //             Id(index as u32)
    //         }

    //         fn from_id(id: Id) -> usize {
    //             id.0 as usize
    //         }
    //     }

    //     let mut map = IdMap::<Id, Cow<'static, str>>::new();
    //     let id1 = map.get_id_mut(Cow::Borrowed("foo"));
    //     let id2 = map.get_id_mut(Cow::Borrowed("bar"));
    //     let id3 = map.get_id_mut(Cow::Borrowed("foo"));
    //     assert_eq!(id1, id3);
    //     assert_ne!(id1, id2);
    //     assert_eq!(map.get_value(id1), "foo");
    //     assert_eq!(map.get_value(id2), "bar");
    // }
}