mirror_mirror/foreign_impls/
btree_map.rs

1use alloc::boxed::Box;
2use alloc::collections::BTreeMap;
3use core::any::Any;
4use core::fmt;
5
6use crate::iter::PairIterMut;
7use crate::type_info::graph::MapNode;
8use crate::type_info::graph::NodeId;
9use crate::type_info::graph::TypeGraph;
10use crate::DescribeType;
11use crate::FromReflect;
12use crate::Map;
13use crate::Reflect;
14use crate::ReflectMut;
15use crate::ReflectOwned;
16use crate::ReflectRef;
17use crate::Value;
18
19impl<K, V> Map for BTreeMap<K, V>
20where
21    K: FromReflect + DescribeType + Ord,
22    V: FromReflect + DescribeType,
23{
24    fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
25        let key = K::from_reflect(key)?;
26        let value = self.get(&key)?;
27        Some(value.as_reflect())
28    }
29
30    fn get_mut(&mut self, key: &dyn Reflect) -> Option<&mut dyn Reflect> {
31        let key = K::from_reflect(key)?;
32        let value = self.get_mut(&key)?;
33        Some(value.as_reflect_mut())
34    }
35
36    fn insert(&mut self, key: &dyn Reflect, value: &dyn Reflect) -> Option<Box<dyn Reflect>> {
37        let key = K::from_reflect(key)?;
38        let value = V::from_reflect(value)?;
39        let previous = BTreeMap::insert(self, key, value)?;
40        Some(Box::new(previous))
41    }
42
43    fn remove(&mut self, key: &dyn Reflect) -> Option<Box<dyn Reflect>> {
44        let key = K::from_reflect(key)?;
45        let previous = BTreeMap::remove(self, &key)?;
46        Some(Box::new(previous))
47    }
48
49    fn len(&self) -> usize {
50        self.len()
51    }
52
53    fn is_empty(&self) -> bool {
54        self.is_empty()
55    }
56
57    fn iter(&self) -> crate::map::Iter<'_> {
58        let iter = self
59            .iter()
60            .map(|(key, value)| (key.as_reflect(), value.as_reflect()));
61        Box::new(iter)
62    }
63
64    fn iter_mut(&mut self) -> PairIterMut<'_, dyn Reflect> {
65        let iter = self
66            .iter_mut()
67            .map(|(key, value)| (key.as_reflect(), value.as_reflect_mut()));
68        Box::new(iter)
69    }
70}
71
72impl<K, V> DescribeType for BTreeMap<K, V>
73where
74    K: DescribeType,
75    V: DescribeType,
76{
77    fn build(graph: &mut TypeGraph) -> NodeId {
78        graph.get_or_build_node_with::<Self, _>(|graph| MapNode::new::<Self, K, V>(graph))
79    }
80}
81
82impl<K, V> Reflect for BTreeMap<K, V>
83where
84    K: FromReflect + DescribeType + Ord,
85    V: FromReflect + DescribeType,
86{
87    trivial_reflect_methods!();
88
89    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
90        ReflectOwned::Map(self)
91    }
92
93    fn reflect_ref(&self) -> ReflectRef<'_> {
94        ReflectRef::Map(self)
95    }
96
97    fn reflect_mut(&mut self) -> ReflectMut<'_> {
98        ReflectMut::Map(self)
99    }
100
101    fn patch(&mut self, value: &dyn Reflect) {
102        if let Some(map) = value.reflect_ref().as_map() {
103            for (key, new_value) in map.iter() {
104                if let Some(value) = Map::get_mut(self, key) {
105                    value.patch(new_value);
106                }
107            }
108        }
109    }
110
111    fn to_value(&self) -> Value {
112        let data = self
113            .iter()
114            .map(|(key, value)| (key.to_value(), value.to_value()))
115            .collect();
116        Value::Map(data)
117    }
118
119    fn clone_reflect(&self) -> Box<dyn Reflect> {
120        let value = self.to_value();
121        Box::new(Self::from_reflect(&value).unwrap())
122    }
123
124    fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
125        f.debug_map().entries(Map::iter(self)).finish()
126    }
127}
128
129impl<K, V> FromReflect for BTreeMap<K, V>
130where
131    K: FromReflect + DescribeType + Ord,
132    V: FromReflect + DescribeType,
133{
134    fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
135        let map = reflect.as_reflect().as_map()?;
136        let mut out = BTreeMap::new();
137        for (key, value) in map.iter() {
138            out.insert(K::from_reflect(key)?, V::from_reflect(value)?);
139        }
140        Some(out)
141    }
142}
143
144impl<K, V> From<BTreeMap<K, V>> for Value
145where
146    K: Reflect,
147    V: Reflect,
148{
149    fn from(map: BTreeMap<K, V>) -> Self {
150        let map = map
151            .into_iter()
152            .map(|(key, value)| (key.to_value(), value.to_value()))
153            .collect();
154        Value::Map(map)
155    }
156}
mirror_mirror/foreign_impls/btree_map.rs

mirror_mirror/foreign_impls/
btree_map.rs
