facet_core/impls_std/
hashmap.rs

1use core::hash::BuildHasher;
2use std::collections::HashMap;
3use std::hash::RandomState;
4
5use crate::ptr::{PtrConst, PtrMut};
6
7use crate::{
8    Def, Facet, IterVTable, MapDef, MapVTable, MarkerTraits, Shape, Type, TypeParam, UserType,
9    ValueVTable, value_vtable,
10};
11
12type HashMapIterator<'mem, K, V> = std::collections::hash_map::Iter<'mem, K, V>;
13
14unsafe impl<'a, K, V, S> Facet<'a> for HashMap<K, V, S>
15where
16    K: Facet<'a> + core::cmp::Eq + core::hash::Hash,
17    V: Facet<'a>,
18    S: Facet<'a> + Default + BuildHasher,
19{
20    const VTABLE: &'static ValueVTable = &const {
21        ValueVTable::builder::<Self>()
22            .marker_traits(|| {
23                let arg_dependent_traits = MarkerTraits::SEND
24                    .union(MarkerTraits::SYNC)
25                    .union(MarkerTraits::EQ)
26                    .union(MarkerTraits::UNPIN)
27                    .union(MarkerTraits::UNWIND_SAFE)
28                    .union(MarkerTraits::REF_UNWIND_SAFE);
29                arg_dependent_traits
30                    .intersection(V::SHAPE.vtable.marker_traits())
31                    .intersection(K::SHAPE.vtable.marker_traits())
32            })
33            .type_name(|f, opts| {
34                if let Some(opts) = opts.for_children() {
35                    write!(f, "{}<", Self::SHAPE.type_identifier)?;
36                    K::SHAPE.vtable.type_name()(f, opts)?;
37                    write!(f, ", ")?;
38                    V::SHAPE.vtable.type_name()(f, opts)?;
39                    write!(f, ">")
40                } else {
41                    write!(f, "{}<⋯>", Self::SHAPE.type_identifier)
42                }
43            })
44            .default_in_place(|| Some(|target| unsafe { target.put(Self::default()) }))
45            .build()
46    };
47
48    const SHAPE: &'static Shape<'static> = &const {
49        Shape::builder_for_sized::<Self>()
50            .type_identifier("HashMap")
51            .type_params(&[
52                TypeParam {
53                    name: "K",
54                    shape: || K::SHAPE,
55                },
56                TypeParam {
57                    name: "V",
58                    shape: || V::SHAPE,
59                },
60                TypeParam {
61                    name: "S",
62                    shape: || S::SHAPE,
63                },
64            ])
65            .ty(Type::User(UserType::Opaque))
66            .def(Def::Map(
67                MapDef::builder()
68                    .k(|| K::SHAPE)
69                    .v(|| V::SHAPE)
70                    .vtable(
71                        &const {
72                            MapVTable::builder()
73                                .init_in_place_with_capacity(|uninit, capacity| unsafe {
74                                    uninit
75                                        .put(Self::with_capacity_and_hasher(capacity, S::default()))
76                                })
77                                .insert(|ptr, key, value| unsafe {
78                                    let map = ptr.as_mut::<HashMap<K, V>>();
79                                    let key = key.read::<K>();
80                                    let value = value.read::<V>();
81                                    map.insert(key, value);
82                                })
83                                .len(|ptr| unsafe {
84                                    let map = ptr.get::<HashMap<K, V>>();
85                                    map.len()
86                                })
87                                .contains_key(|ptr, key| unsafe {
88                                    let map = ptr.get::<HashMap<K, V>>();
89                                    map.contains_key(key.get())
90                                })
91                                .get_value_ptr(|ptr, key| unsafe {
92                                    let map = ptr.get::<HashMap<K, V>>();
93                                    map.get(key.get()).map(|v| PtrConst::new(v))
94                                })
95                                .iter_vtable(
96                                    IterVTable::builder()
97                                        .init_with_value(|ptr| unsafe {
98                                            let map = ptr.get::<HashMap<K, V>>();
99                                            let iter: HashMapIterator<'_, K, V> = map.iter();
100                                            let iter_state = Box::new(iter);
101                                            PtrMut::new(Box::into_raw(iter_state) as *mut u8)
102                                        })
103                                        .next(|iter_ptr| unsafe {
104                                            let state =
105                                                iter_ptr.as_mut::<HashMapIterator<'_, K, V>>();
106                                            state.next().map(|(key, value)| {
107                                                (
108                                                    PtrConst::new(key as *const K),
109                                                    PtrConst::new(value as *const V),
110                                                )
111                                            })
112                                        })
113                                        .dealloc(|iter_ptr| unsafe {
114                                            drop(Box::from_raw(
115                                                iter_ptr.as_ptr::<HashMapIterator<'_, K, V>>()
116                                                    as *mut HashMapIterator<'_, K, V>,
117                                            ));
118                                        })
119                                        .build(),
120                                )
121                                .build()
122                        },
123                    )
124                    .build(),
125            ))
126            .build()
127    };
128}
129
130unsafe impl Facet<'_> for RandomState {
131    const VTABLE: &'static ValueVTable =
132        &const { value_vtable!((), |f, _opts| write!(f, "{}", Self::SHAPE.type_identifier)) };
133
134    const SHAPE: &'static Shape<'static> = &const {
135        Shape::builder_for_sized::<Self>()
136            .type_identifier("RandomState")
137            .ty(Type::User(UserType::Opaque))
138            .def(Def::Scalar)
139            .build()
140    };
141}
facet_core/impls_std/hashmap.rs

facet_core/impls_std/
hashmap.rs
