mirror_mirror/
value.rs

1use alloc::borrow::ToOwned;
2use alloc::boxed::Box;
3use alloc::collections::BTreeMap;
4use alloc::string::String;
5use alloc::vec::Vec;
6use core::any::Any;
7use core::cmp::Ordering;
8use core::fmt;
9use core::hash::Hash;
10use core::hash::Hasher;
11
12use tiny_ordered_float::{OrderedF32, OrderedF64};
13
14use crate::enum_::EnumValue;
15use crate::struct_::StructValue;
16use crate::tuple::TupleValue;
17use crate::tuple_struct::TupleStructValue;
18use crate::type_info::graph::NodeId;
19use crate::type_info::graph::OpaqueNode;
20use crate::type_info::graph::TypeGraph;
21use crate::DescribeType;
22use crate::FromReflect;
23use crate::Reflect;
24use crate::ReflectMut;
25use crate::ReflectOwned;
26use crate::ReflectRef;
27use crate::ScalarMut;
28use crate::ScalarOwned;
29use crate::ScalarRef;
30use crate::TypeDescriptor;
31
32/// A type erased value type.
33///
34/// Constructed with [`Reflect::to_value`].
35#[allow(non_camel_case_types)]
36#[derive(Debug, Clone)]
37#[cfg_attr(feature = "speedy", derive(speedy::Readable, speedy::Writable))]
38#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
39pub enum Value {
40    usize(usize),
41    u8(u8),
42    u16(u16),
43    u32(u32),
44    u64(u64),
45    u128(u128),
46    i8(i8),
47    i16(i16),
48    i32(i32),
49    i64(i64),
50    i128(i128),
51    bool(bool),
52    char(char),
53    f32(f32),
54    f64(f64),
55    String(String),
56    StructValue(Box<StructValue>),
57    EnumValue(Box<EnumValue>),
58    TupleStructValue(TupleStructValue),
59    TupleValue(TupleValue),
60    List(Vec<Value>),
61    Map(BTreeMap<Value, Value>),
62}
63
64impl FromReflect for Value {
65    fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
66        Some(reflect.to_value())
67    }
68}
69
70#[allow(non_camel_case_types)]
71#[derive(Eq, PartialEq, PartialOrd, Ord, Hash)]
72enum OrdEqHashValue<'a> {
73    usize(usize),
74    u8(u8),
75    u16(u16),
76    u32(u32),
77    u64(u64),
78    u128(u128),
79    i8(i8),
80    i16(i16),
81    i32(i32),
82    i64(i64),
83    i128(i128),
84    bool(bool),
85    char(char),
86    f32(OrderedF32),
87    f64(OrderedF64),
88    String(&'a str),
89    StructValue(&'a StructValue),
90    EnumValue(&'a EnumValue),
91    TupleStructValue(&'a TupleStructValue),
92    TupleValue(&'a TupleValue),
93    List(&'a [Value]),
94    Map(&'a BTreeMap<Value, Value>),
95}
96
97impl<'a> From<&'a Value> for OrdEqHashValue<'a> {
98    fn from(value: &'a Value) -> Self {
99        match value {
100            Value::usize(inner) => OrdEqHashValue::usize(*inner),
101            Value::u8(inner) => OrdEqHashValue::u8(*inner),
102            Value::u16(inner) => OrdEqHashValue::u16(*inner),
103            Value::u32(inner) => OrdEqHashValue::u32(*inner),
104            Value::u64(inner) => OrdEqHashValue::u64(*inner),
105            Value::u128(inner) => OrdEqHashValue::u128(*inner),
106            Value::i8(inner) => OrdEqHashValue::i8(*inner),
107            Value::i16(inner) => OrdEqHashValue::i16(*inner),
108            Value::i32(inner) => OrdEqHashValue::i32(*inner),
109            Value::i64(inner) => OrdEqHashValue::i64(*inner),
110            Value::i128(inner) => OrdEqHashValue::i128(*inner),
111            Value::bool(inner) => OrdEqHashValue::bool(*inner),
112            Value::char(inner) => OrdEqHashValue::char(*inner),
113            Value::f32(inner) => OrdEqHashValue::f32(OrderedF32(*inner)),
114            Value::f64(inner) => OrdEqHashValue::f64(OrderedF64(*inner)),
115            Value::String(inner) => OrdEqHashValue::String(inner),
116            Value::StructValue(inner) => OrdEqHashValue::StructValue(inner),
117            Value::EnumValue(inner) => OrdEqHashValue::EnumValue(inner),
118            Value::TupleStructValue(inner) => OrdEqHashValue::TupleStructValue(inner),
119            Value::TupleValue(inner) => OrdEqHashValue::TupleValue(inner),
120            Value::List(inner) => OrdEqHashValue::List(inner),
121            Value::Map(inner) => OrdEqHashValue::Map(inner),
122        }
123    }
124}
125
126impl PartialEq for Value {
127    fn eq(&self, other: &Self) -> bool {
128        OrdEqHashValue::from(self) == OrdEqHashValue::from(other)
129    }
130}
131
132impl Eq for Value {}
133
134impl PartialOrd for Value {
135    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
136        Some(self.cmp(other))
137    }
138}
139
140impl Ord for Value {
141    fn cmp(&self, other: &Self) -> Ordering {
142        OrdEqHashValue::from(self).cmp(&OrdEqHashValue::from(other))
143    }
144}
145
146impl Hash for Value {
147    fn hash<H>(&self, state: &mut H)
148    where
149        H: Hasher,
150    {
151        OrdEqHashValue::from(self).hash(state);
152    }
153}
154
155macro_rules! for_each_variant {
156    ($self:expr, $inner:ident => $expr:expr) => {
157        match $self {
158            Value::usize($inner) => $expr,
159            Value::u8($inner) => $expr,
160            Value::u16($inner) => $expr,
161            Value::u32($inner) => $expr,
162            Value::u64($inner) => $expr,
163            Value::u128($inner) => $expr,
164            Value::i8($inner) => $expr,
165            Value::i16($inner) => $expr,
166            Value::i32($inner) => $expr,
167            Value::i64($inner) => $expr,
168            Value::i128($inner) => $expr,
169            Value::bool($inner) => $expr,
170            Value::char($inner) => $expr,
171            Value::f32($inner) => $expr,
172            Value::f64($inner) => $expr,
173            Value::String($inner) => $expr,
174            Value::StructValue($inner) => $expr,
175            Value::TupleStructValue($inner) => $expr,
176            Value::EnumValue($inner) => $expr,
177            Value::TupleValue($inner) => $expr,
178            Value::List($inner) => $expr,
179            Value::Map($inner) => $expr,
180        }
181    };
182}
183
184impl DescribeType for Value {
185    fn build(graph: &mut TypeGraph) -> NodeId {
186        graph.get_or_build_node_with::<Self, _>(|graph| {
187            OpaqueNode::new::<Self>(Default::default(), graph)
188        })
189    }
190}
191
192impl Reflect for Value {
193    fn type_descriptor(&self) -> alloc::borrow::Cow<'static, TypeDescriptor> {
194        <Self as DescribeType>::type_descriptor()
195    }
196
197    fn as_any(&self) -> &dyn Any {
198        for_each_variant!(self, inner => inner)
199    }
200
201    fn as_any_mut(&mut self) -> &mut dyn Any {
202        for_each_variant!(self, inner => inner)
203    }
204
205    fn as_reflect(&self) -> &dyn Reflect {
206        for_each_variant!(self, inner => inner)
207    }
208
209    fn as_reflect_mut(&mut self) -> &mut dyn Reflect {
210        for_each_variant!(self, inner => inner)
211    }
212
213    fn reflect_owned(self: Box<Self>) -> ReflectOwned {
214        match *self {
215            Value::usize(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
216            Value::u8(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
217            Value::u16(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
218            Value::u32(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
219            Value::u64(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
220            Value::u128(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
221            Value::i8(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
222            Value::i16(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
223            Value::i32(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
224            Value::i64(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
225            Value::i128(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
226            Value::bool(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
227            Value::char(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
228            Value::f32(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
229            Value::f64(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
230            Value::String(inner) => ReflectOwned::Scalar(ScalarOwned::from(inner)),
231            Value::StructValue(inner) => ReflectOwned::Struct(inner),
232            Value::EnumValue(inner) => ReflectOwned::Enum(inner),
233            Value::TupleStructValue(inner) => ReflectOwned::TupleStruct(Box::new(inner)),
234            Value::TupleValue(inner) => ReflectOwned::Tuple(Box::new(inner)),
235            Value::List(inner) => ReflectOwned::List(Box::new(inner)),
236            Value::Map(inner) => ReflectOwned::Map(Box::new(inner)),
237        }
238    }
239
240    fn reflect_ref(&self) -> ReflectRef<'_> {
241        match self {
242            Value::usize(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
243            Value::u8(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
244            Value::u16(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
245            Value::u32(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
246            Value::u64(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
247            Value::u128(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
248            Value::i8(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
249            Value::i16(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
250            Value::i32(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
251            Value::i64(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
252            Value::i128(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
253            Value::bool(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
254            Value::char(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
255            Value::f32(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
256            Value::f64(inner) => ReflectRef::Scalar(ScalarRef::from(*inner)),
257            Value::String(inner) => ReflectRef::Scalar(ScalarRef::from(inner)),
258            Value::StructValue(inner) => ReflectRef::Struct(&**inner),
259            Value::EnumValue(inner) => ReflectRef::Enum(&**inner),
260            Value::TupleStructValue(inner) => ReflectRef::TupleStruct(inner),
261            Value::TupleValue(inner) => ReflectRef::Tuple(inner),
262            Value::List(inner) => ReflectRef::List(inner),
263            Value::Map(inner) => ReflectRef::Map(inner),
264        }
265    }
266
267    fn reflect_mut(&mut self) -> ReflectMut<'_> {
268        match self {
269            Value::usize(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
270            Value::u8(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
271            Value::u16(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
272            Value::u32(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
273            Value::u64(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
274            Value::u128(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
275            Value::i8(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
276            Value::i16(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
277            Value::i32(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
278            Value::i64(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
279            Value::i128(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
280            Value::bool(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
281            Value::char(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
282            Value::f32(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
283            Value::f64(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
284            Value::String(inner) => ReflectMut::Scalar(ScalarMut::from(inner)),
285            Value::StructValue(inner) => ReflectMut::Struct(&mut **inner),
286            Value::EnumValue(inner) => ReflectMut::Enum(&mut **inner),
287            Value::TupleStructValue(inner) => ReflectMut::TupleStruct(inner),
288            Value::TupleValue(inner) => ReflectMut::Tuple(inner),
289            Value::List(inner) => ReflectMut::List(inner),
290            Value::Map(inner) => ReflectMut::Map(inner),
291        }
292    }
293
294    fn patch(&mut self, value: &dyn Reflect) {
295        for_each_variant!(self, inner => inner.patch(value))
296    }
297
298    fn to_value(&self) -> Value {
299        self.clone()
300    }
301
302    fn clone_reflect(&self) -> Box<dyn Reflect> {
303        Box::new(self.clone())
304    }
305
306    fn debug(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
307        if f.alternate() {
308            write!(f, "{self:#?}")
309        } else {
310            write!(f, "{self:?}")
311        }
312    }
313}
314
315macro_rules! from_impls {
316    (
317        $($ident:ident)*
318    ) => {
319        $(
320            impl From<$ident> for Value {
321                fn from(value: $ident) -> Self {
322                    Value::$ident(value)
323                }
324            }
325        )*
326    };
327}
328
329impl From<StructValue> for Value {
330    fn from(value: StructValue) -> Self {
331        Value::StructValue(Box::new(value))
332    }
333}
334
335impl From<EnumValue> for Value {
336    fn from(value: EnumValue) -> Self {
337        Value::EnumValue(Box::new(value))
338    }
339}
340
341impl From<&str> for Value {
342    fn from(value: &str) -> Self {
343        value.to_owned().into()
344    }
345}
346
347impl From<&dyn Reflect> for Value {
348    fn from(reflect: &dyn Reflect) -> Self {
349        reflect.to_value()
350    }
351}
352
353from_impls! {
354    usize u8 u16 u32 u64 u128
355    i8 i16 i32 i64 i128
356    f32 f64
357    bool char String
358    TupleValue TupleStructValue
359}
mirror_mirror/value.rs

mirror_mirror/
value.rs
