hotel 1.0.5

Collection Data-structure to associate values with keys
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use crate::{Hotel, HotelIter};
use std::{collections::HashMap, hash::Hash};

pub struct HotelMap<K, V>
where
    K: Hash + Eq,
{
    // Hold the values inside a hotel
    hotel: Hotel<V>,
    // Store keys in a HashMap
    map: HashMap<K, usize>,
}

impl<K, V> std::fmt::Debug for HotelMap<K, V>
where
    K: Hash + Eq + std::fmt::Debug,
    V: std::fmt::Debug,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "HotelMap [")?;
        let mut first = true;
        for (k, v) in &self.map {
            if first {
                first = false;
            } else {
                write!(f, ", ")?;
            }

            let v = &self.hotel.floor[*v];
            write!(f, "{k:?} => {v:?}")?;
        }
        write!(f, "]")
    }
}

impl<K: Hash + Eq, V> Default for HotelMap<K, V> {
    fn default() -> Self {
        Self {
            hotel: Hotel::new(),
            map: HashMap::new(),
        }
    }
}

impl<K: Hash + Eq, V> IntoIterator for HotelMap<K, V> {
    type Item = (usize, V);

    type IntoIter = HotelIter<V>;

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

impl<K, V> HotelMap<K, V>
where
    K: Hash + Eq,
{
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_capacity(capacity: usize) -> HotelMap<K, V> {
        Self {
            hotel: Hotel::with_capacity(capacity),
            map: HashMap::with_capacity(capacity),
        }
    }

    pub fn get_by_key(&self, key: &K) -> Option<(usize, &V)> {
        let index = *self.map.get(key)?;
        Some((index, self.get_by_index(index)?))
    }

    pub fn get_by_index(&self, index: usize) -> Option<&V> {
        self.hotel.get(index)
    }

    pub fn set_by_index(&mut self, index: usize, item: V) {
        self.hotel.set(index, item);
    }

    pub fn contains(&self, key: &K) -> bool {
        self.map.get(key).is_some()
    }

    /// Returns slot index of inserted item.
    pub fn insert(&mut self, key: K, value: V) -> usize {
        match self.map.entry(key) {
            std::collections::hash_map::Entry::Occupied(index) => {
                let index = *index.get();
                self.hotel.floor[index] = Some(value);
                index
            }
            std::collections::hash_map::Entry::Vacant(slot) => {
                let index = self.hotel.put(value);
                slot.insert(index);
                index
            }
        }
    }

    /// Only inserts, if no item with same key is present in HotelMap.
    /// Returns slot index of inserted item
    /// or None, if item was already present in hotel
    pub fn try_insert(&mut self, key: K, value: V) -> Option<usize> {
        match self.map.entry(key) {
            std::collections::hash_map::Entry::Occupied(_) => None,
            std::collections::hash_map::Entry::Vacant(slot) => {
                let index = self.hotel.put(value);
                slot.insert(index);
                Some(index)
            }
        }
    }

    /// Iterates only over the values and their indices
    pub fn iter_values(&self) -> impl Iterator<Item = (usize, &V)> {
        self.hotel.iter()
    }

    /// Iterate over all keys, indices and values in the hotel
    pub fn iter(&self) -> impl Iterator<Item = (&K, usize, &V)> {
        self.map.iter().map(|(key, index)| {
            (
                key,
                *index,
                self.hotel
                    .get(*index)
                    .expect("keys of HotelMap to always be valid Hotel keys"),
            )
        })
    }
}