rkyv/collections/swiss_table/
index_set.rs

1//! An archived index set implementation based on Google's high-performance
2//! SwissTable hash map.
3
4use core::{
5    borrow::Borrow,
6    fmt,
7    hash::{Hash, Hasher},
8};
9
10use munge::munge;
11use rancor::{Fallible, Source};
12
13use crate::{
14    collections::swiss_table::{
15        index_map::Keys, ArchivedIndexMap, IndexMapResolver,
16    },
17    hash::FxHasher64,
18    ser::{Allocator, Writer},
19    Place, Portable, Serialize,
20};
21
22/// An archived `IndexSet`.
23#[derive(Portable)]
24#[rkyv(crate)]
25#[cfg_attr(feature = "bytecheck", derive(bytecheck::CheckBytes))]
26#[repr(transparent)]
27pub struct ArchivedIndexSet<K, H = FxHasher64> {
28    inner: ArchivedIndexMap<K, (), H>,
29}
30
31impl<K, H> ArchivedIndexSet<K, H> {
32    /// Returns whether the index set contains no values.
33    pub fn is_empty(&self) -> bool {
34        self.inner.is_empty()
35    }
36
37    /// Returns an iterator over the keys of the index set in order.
38    pub fn iter(&self) -> Keys<'_, K, ()> {
39        self.inner.keys()
40    }
41
42    /// Returns the number of elements in the index set.
43    pub fn len(&self) -> usize {
44        self.inner.len()
45    }
46}
47
48impl<K, H: Default + Hasher> ArchivedIndexSet<K, H> {
49    /// Returns whether a key is present in the hash set.
50    pub fn contains<Q>(&self, k: &Q) -> bool
51    where
52        K: Borrow<Q>,
53        Q: Hash + Eq + ?Sized,
54    {
55        self.inner.contains_key(k)
56    }
57
58    /// Returns the value stored in the set, if any.
59    pub fn get<Q>(&self, k: &Q) -> Option<&K>
60    where
61        K: Borrow<Q>,
62        Q: Hash + Eq + ?Sized,
63    {
64        self.inner.get_full(k).map(|(_, k, _)| k)
65    }
66
67    /// Returns the item index and value stored in the set, if any.
68    pub fn get_full<Q>(&self, k: &Q) -> Option<(usize, &K)>
69    where
70        K: Borrow<Q>,
71        Q: Hash + Eq + ?Sized,
72    {
73        self.inner.get_full(k).map(|(i, k, _)| (i, k))
74    }
75
76    /// Gets a key by index.
77    pub fn get_index(&self, index: usize) -> Option<&K> {
78        self.inner.get_index(index).map(|(k, _)| k)
79    }
80
81    /// Returns the index of a key if it exists in the set.
82    pub fn get_index_of<Q>(&self, key: &Q) -> Option<usize>
83    where
84        K: Borrow<Q>,
85        Q: Hash + Eq + ?Sized,
86    {
87        self.inner.get_index_of(key)
88    }
89
90    /// Resolves an archived index map from a given length and parameters.
91    pub fn resolve_from_len(
92        len: usize,
93        load_factor: (usize, usize),
94        resolver: IndexSetResolver,
95        out: Place<Self>,
96    ) {
97        munge!(let ArchivedIndexSet { inner } = out);
98        ArchivedIndexMap::resolve_from_len(len, load_factor, resolver.0, inner);
99    }
100
101    /// Serializes an iterator of keys as an index set.
102    pub fn serialize_from_iter<I, UK, S>(
103        iter: I,
104        load_factor: (usize, usize),
105        serializer: &mut S,
106    ) -> Result<IndexSetResolver, S::Error>
107    where
108        I: Clone + ExactSizeIterator,
109        I::Item: Borrow<UK>,
110        UK: Serialize<S, Archived = K> + Hash + Eq,
111        S: Fallible + Writer + Allocator + ?Sized,
112        S::Error: Source,
113    {
114        Ok(IndexSetResolver(
115            ArchivedIndexMap::<K, (), H>::serialize_from_iter::<
116                _,
117                _,
118                (),
119                _,
120                _,
121                _,
122            >(iter.map(|x| (x, ())), load_factor, serializer)?,
123        ))
124    }
125}
126
127impl<K: fmt::Debug, H> fmt::Debug for ArchivedIndexSet<K, H> {
128    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
129        f.debug_set().entries(self.iter()).finish()
130    }
131}
132
133impl<K: PartialEq, H> PartialEq for ArchivedIndexSet<K, H> {
134    fn eq(&self, other: &Self) -> bool {
135        self.iter().eq(other.iter())
136    }
137}
138
139impl<K: Eq, H> Eq for ArchivedIndexSet<K, H> {}
140
141/// The resolver for archived index sets.
142pub struct IndexSetResolver(IndexMapResolver);
rkyv/collections/swiss_table/index_set.rs

rkyv/collections/swiss_table/
index_set.rs
