facet_core/impls_std/
hashmap.rs

1use alloc::collections::VecDeque;
2use core::hash::{BuildHasher, Hash};
3use std::collections::HashMap;
4use std::hash::RandomState;
5
6use crate::ptr::{PtrConst, PtrMut};
7
8use crate::{
9    Def, Facet, MapDef, MapIterVTable, MapVTable, MarkerTraits, ScalarAffinity, ScalarDef, Shape,
10    TypeParam, VTableView, ValueVTable, value_vtable,
11};
12
13struct HashMapIterator<'mem, K> {
14    map: PtrConst<'mem>,
15    keys: VecDeque<&'mem K>,
16}
17
18unsafe impl<'a, K, V, S> Facet<'a> for HashMap<K, V, S>
19where
20    K: Facet<'a> + core::cmp::Eq + core::hash::Hash,
21    V: Facet<'a>,
22    S: Facet<'a> + Default + BuildHasher,
23{
24    const SHAPE: &'static Shape = &const {
25        Shape::builder_for_sized::<Self>()
26            .type_params(&[
27                TypeParam {
28                    name: "K",
29                    shape: || K::SHAPE,
30                },
31                TypeParam {
32                    name: "V",
33                    shape: || V::SHAPE,
34                },
35                TypeParam {
36                    name: "S",
37                    shape: || S::SHAPE,
38                },
39            ])
40            .vtable(
41                &const {
42                    let mut builder = ValueVTable::builder::<Self>()
43                        .marker_traits({
44                            let arg_dependent_traits = MarkerTraits::SEND
45                                .union(MarkerTraits::SYNC)
46                                .union(MarkerTraits::EQ)
47                                .union(MarkerTraits::UNPIN);
48                            arg_dependent_traits
49                                .intersection(V::SHAPE.vtable.marker_traits)
50                                .intersection(K::SHAPE.vtable.marker_traits)
51                        })
52                        .type_name(|f, opts| {
53                            if let Some(opts) = opts.for_children() {
54                                write!(f, "HashMap<")?;
55                                (K::SHAPE.vtable.type_name)(f, opts)?;
56                                write!(f, ", ")?;
57                                (V::SHAPE.vtable.type_name)(f, opts)?;
58                                write!(f, ">")
59                            } else {
60                                write!(f, "HashMap<⋯>")
61                            }
62                        });
63
64                    if K::SHAPE.vtable.debug.is_some() && V::SHAPE.vtable.debug.is_some() {
65                        builder = builder.debug(|value, f| {
66                            let k_debug = <VTableView<K>>::of().debug().unwrap();
67                            let v_debug = <VTableView<V>>::of().debug().unwrap();
68                            write!(f, "{{")?;
69                            for (i, (key, val)) in value.iter().enumerate() {
70                                if i > 0 {
71                                    write!(f, ", ")?;
72                                }
73                                (k_debug)(key, f)?;
74                                write!(f, ": ")?;
75                                (v_debug)(val, f)?;
76                            }
77                            write!(f, "}}")
78                        });
79                    }
80
81                    builder =
82                        builder.default_in_place(|target| unsafe { target.put(Self::default()) });
83
84                    // FIXME: THIS IS VERY WRONG
85                    builder =
86                        builder.clone_into(|src, dst| unsafe { dst.put(core::ptr::read(src)) });
87
88                    if V::SHAPE.vtable.eq.is_some() {
89                        builder = builder.eq(|a, b| {
90                            let v_eq = <VTableView<V>>::of().eq().unwrap();
91                            a.len() == b.len()
92                                && a.iter().all(|(key_a, val_a)| {
93                                    b.get(key_a).is_some_and(|val_b| (v_eq)(val_a, val_b))
94                                })
95                        });
96                    }
97
98                    if V::SHAPE.vtable.hash.is_some() {
99                        builder = builder.hash(|map, hasher_this, hasher_write_fn| unsafe {
100                            use crate::HasherProxy;
101                            let v_hash = <VTableView<V>>::of().hash().unwrap();
102                            let mut hasher = HasherProxy::new(hasher_this, hasher_write_fn);
103                            map.len().hash(&mut hasher);
104                            for (k, v) in map {
105                                k.hash(&mut hasher);
106                                (v_hash)(v, hasher_this, hasher_write_fn);
107                            }
108                        });
109                    }
110
111                    builder.build()
112                },
113            )
114            .def(Def::Map(
115                MapDef::builder()
116                    .k(K::SHAPE)
117                    .v(V::SHAPE)
118                    .vtable(
119                        &const {
120                            MapVTable::builder()
121                                .init_in_place_with_capacity(|uninit, capacity| unsafe {
122                                    uninit
123                                        .put(Self::with_capacity_and_hasher(capacity, S::default()))
124                                })
125                                .insert(|ptr, key, value| unsafe {
126                                    let map = ptr.as_mut::<HashMap<K, V>>();
127                                    let key = key.read::<K>();
128                                    let value = value.read::<V>();
129                                    map.insert(key, value);
130                                })
131                                .len(|ptr| unsafe {
132                                    let map = ptr.get::<HashMap<K, V>>();
133                                    map.len()
134                                })
135                                .contains_key(|ptr, key| unsafe {
136                                    let map = ptr.get::<HashMap<K, V>>();
137                                    map.contains_key(key.get())
138                                })
139                                .get_value_ptr(|ptr, key| unsafe {
140                                    let map = ptr.get::<HashMap<K, V>>();
141                                    map.get(key.get()).map(|v| PtrConst::new(v))
142                                })
143                                .iter(|ptr| unsafe {
144                                    let map = ptr.get::<HashMap<K, V>>();
145                                    let keys: VecDeque<&K> = map.keys().collect();
146                                    let iter_state = Box::new(HashMapIterator { map: ptr, keys });
147                                    PtrMut::new(Box::into_raw(iter_state) as *mut u8)
148                                })
149                                .iter_vtable(
150                                    MapIterVTable::builder()
151                                        .next(|iter_ptr| unsafe {
152                                            let state = iter_ptr.as_mut::<HashMapIterator<'_, K>>();
153                                            let map = state.map.get::<HashMap<K, V>>();
154                                            while let Some(key) = state.keys.pop_front() {
155                                                if let Some(value) = map.get(key) {
156                                                    return Some((
157                                                        PtrConst::new(key as *const K),
158                                                        PtrConst::new(value as *const V),
159                                                    ));
160                                                }
161                                            }
162
163                                            None
164                                        })
165                                        .dealloc(|iter_ptr| unsafe {
166                                            drop(Box::from_raw(
167                                                iter_ptr.as_ptr::<HashMapIterator<'_, K>>()
168                                                    as *mut HashMapIterator<'_, K>,
169                                            ));
170                                        })
171                                        .build(),
172                                )
173                                .build()
174                        },
175                    )
176                    .build(),
177            ))
178            .build()
179    };
180}
181
182unsafe impl Facet<'_> for RandomState {
183    const SHAPE: &'static Shape = &const {
184        Shape::builder_for_sized::<Self>()
185            .def(Def::Scalar(
186                ScalarDef::builder()
187                    .affinity(ScalarAffinity::opaque().build())
188                    .build(),
189            ))
190            .vtable(&const { value_vtable!((), |f, _opts| write!(f, "RandomState")) })
191            .build()
192    };
193}
facet_core/impls_std/hashmap.rs

facet_core/impls_std/
hashmap.rs
