bumpish 0.2.0

A set of collections using bump allocations
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
135
136
137
138
139

use super::bucket::{Bucket, BucketPtr};
use super::inner::Core;
use core::fmt::{self, Debug};

pub enum Entry<'a, K, V> {
    /// Existing slot with equivalent key.
    Occupied(OccupiedEntry<'a, K, V>),

    /// Vacant slot (no equivalent key in the map).
    Vacant(VacantEntry<'a, K, V>),
}

impl<'a, K, V> Entry<'a, K, V> {
    pub fn or_insert(self, value: V) -> &'a V {
        self.or_insert_with(|| value)
    }

    pub fn or_insert_with<F>(self, with: F) -> &'a V
    where
        F: FnOnce() -> V,
    {
        match self {
            Entry::Occupied(entry) => entry.into_ref(),
            Entry::Vacant(entry) => entry.insert(with()),
        }
    }

    pub fn or_insert_with_key<F>(self, with_key: F) -> &'a V
    where
        F: FnOnce(&K) -> V,
    {
        match self {
            Entry::Occupied(entry) => entry.into_ref(),
            Entry::Vacant(entry) => {
                let value = with_key(entry.key());
                entry.insert(value)
            }
        }
    }

    pub fn key(&self) -> &K {
        match self {
            Entry::Occupied(entry) => entry.key(),
            Entry::Vacant(entry) => entry.key(),
        }
    }
}

impl<'a, K, V: Default> Entry<'a, K, V> {
    pub fn or_default(self) -> &'a V {
        self.or_insert_with(|| Default::default())
    }
}

impl<K: Debug, V: Debug> Debug for Entry<'_, K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Entry::Vacant(v) => f.debug_tuple("Entry").field(v).finish(),
            Entry::Occupied(o) => f.debug_tuple("Entry").field(o).finish(),
        }
    }
}

pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
    bucket: &'a Bucket<K, V>,
}

impl<'a, K, V> OccupiedEntry<'a, K, V> {
    pub(super) unsafe fn new(bucket_ptr: BucketPtr<K, V>) -> Self {
        Self {
            bucket: unsafe { bucket_ptr.as_ref() },
        }
    }

    #[inline]
    pub fn key(&self) -> &K {
        &self.bucket.key
    }

    #[inline]
    pub fn get(&self) -> &V {
        &self.bucket.value
    }

    #[inline]
    pub fn into_ref(self) -> &'a V {
        self.bucket.as_tuple().1
    }
}

impl<K: Debug, V: Debug> Debug for OccupiedEntry<'_, K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("OccupiedEntry")
            .field("key", self.key())
            .field("value", self.get())
            .finish_non_exhaustive()
    }
}

pub struct VacantEntry<'a, K, V> {
    hash: u64,
    key: K,
    core: &'a Core<K, V>,
}

impl<'a, K, V> VacantEntry<'a, K, V> {
    pub(super) fn new(hash: u64, key: K, core: &'a Core<K, V>) -> Self {
        Self { hash, key, core }
    }

    #[inline]
    pub fn key(&self) -> &K {
        &self.key
    }

    #[inline]
    pub fn into_key(self) -> K {
        self.key
    }

    pub fn insert(self, value: V) -> &'a V {
        let bucket_ptr = self.core.insert_unique(self.hash, self.key, value);
        let bucket = unsafe { bucket_ptr.as_ref() };
        &bucket.value
    }

    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
        let bucket_ptr = self.core.insert_unique(self.hash, self.key, value);
        unsafe { OccupiedEntry::new(bucket_ptr) }
    }
}

impl<K: Debug, V: Debug> Debug for VacantEntry<'_, K, V> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("VacantEntry")
            .field("key", self.key())
            .finish_non_exhaustive()
    }
}