facet_reflect/peek/
map.rs

1use facet_core::{MapDef, Opaque, OpaqueConst};
2
3use crate::Peek;
4
5use super::PeekValue;
6
7/// Iterator over key-value pairs in a `PeekMap`
8pub struct PeekMapIter<'mem> {
9    map: PeekMap<'mem>,
10    iter: Opaque<'mem>,
11}
12
13impl<'mem> Iterator for PeekMapIter<'mem> {
14    type Item = (Peek<'mem>, Peek<'mem>);
15
16    fn next(&mut self) -> Option<Self::Item> {
17        unsafe {
18            let next = (self.map.def.vtable.iter_vtable.next)(self.iter);
19            next.map(|(key_ptr, value_ptr)| {
20                (
21                    Peek::unchecked_new(key_ptr, self.map.def.k),
22                    Peek::unchecked_new(value_ptr, self.map.def.v),
23                )
24            })
25        }
26    }
27}
28
29impl Drop for PeekMapIter<'_> {
30    fn drop(&mut self) {
31        unsafe { (self.map.def.vtable.iter_vtable.dealloc)(self.iter) }
32    }
33}
34
35impl<'mem> IntoIterator for &'mem PeekMap<'mem> {
36    type Item = (Peek<'mem>, Peek<'mem>);
37    type IntoIter = PeekMapIter<'mem>;
38
39    fn into_iter(self) -> Self::IntoIter {
40        self.iter()
41    }
42}
43
44/// Lets you read from a map (implements read-only [`facet_core::MapVTable`] proxies)
45#[derive(Clone, Copy)]
46pub struct PeekMap<'mem> {
47    value: PeekValue<'mem>,
48    def: MapDef,
49}
50
51impl<'mem> core::ops::Deref for PeekMap<'mem> {
52    type Target = PeekValue<'mem>;
53
54    #[inline(always)]
55    fn deref(&self) -> &Self::Target {
56        &self.value
57    }
58}
59
60impl<'mem> PeekMap<'mem> {
61    /// Constructor
62    pub fn new(value: PeekValue<'mem>, def: MapDef) -> Self {
63        Self { value, def }
64    }
65
66    /// Get the number of entries in the map
67    pub fn len(&self) -> usize {
68        unsafe { (self.def.vtable.len_fn)(self.value.data()) }
69    }
70
71    /// Returns true if the map is empty
72    pub fn is_empty(&self) -> bool {
73        self.len() == 0
74    }
75
76    /// Check if the map contains a key
77    pub fn contains_key(&self, key: &impl facet_core::Facet) -> bool {
78        unsafe {
79            let key_ptr = OpaqueConst::new(key);
80            (self.def.vtable.contains_key_fn)(self.value.data(), key_ptr)
81        }
82    }
83
84    /// Get a value from the map for the given key
85    pub fn get<'k>(&self, key: &'k impl facet_core::Facet) -> Option<Peek<'mem>> {
86        unsafe {
87            let key_ptr = OpaqueConst::new(key);
88            let value_ptr = (self.def.vtable.get_value_ptr_fn)(self.value.data(), key_ptr)?;
89            Some(Peek::unchecked_new(value_ptr, self.def.v))
90        }
91    }
92
93    /// Returns an iterator over the key-value pairs in the map
94    pub fn iter(self) -> PeekMapIter<'mem> {
95        let iter = unsafe { (self.def.vtable.iter_fn)(self.value.data()) };
96        PeekMapIter { map: self, iter }
97    }
98}
facet_reflect/peek/map.rs

facet_reflect/peek/
map.rs
