1use alloc::boxed::Box;
2use alloc::vec::Vec;
3use core::any::Any;
4use core::fmt;
5use core::fmt::Debug;
6use core::iter::FusedIterator;
7
8use crate::iter::ValueIterMut;
9use crate::type_info::graph::NodeId;
10use crate::type_info::graph::OpaqueNode;
11use crate::type_info::graph::TupleNode;
12use crate::type_info::graph::TypeGraph;
13use crate::type_info::graph::UnnamedFieldNode;
14use crate::DescribeType;
15use crate::FromReflect;
16use crate::Reflect;
17use crate::ReflectMut;
18use crate::ReflectOwned;
19use crate::ReflectRef;
20use crate::Value;
21
22pub trait Tuple: Reflect {
24 fn field_at(&self, index: usize) -> Option<&dyn Reflect>;
25
26 fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect>;
27
28 fn fields(&self) -> Iter<'_>;
29
30 fn fields_mut(&mut self) -> ValueIterMut<'_>;
31
32 fn fields_len(&self) -> usize;
33}
34
35impl fmt::Debug for dyn Tuple {
36 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
37 self.as_reflect().debug(f)
38 }
39}
40
41#[derive(Default, Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
42#[cfg_attr(feature = "speedy", derive(speedy::Readable, speedy::Writable))]
43#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
44pub struct TupleValue {
45 fields: Vec<Value>,
46}
47
48impl TupleValue {
49 pub fn new() -> Self {
50 Self::default()
51 }
52
53 pub fn with_capacity(capacity: usize) -> Self {
54 Self {
55 fields: Vec::with_capacity(capacity),
56 }
57 }
58
59 pub fn with_field(mut self, value: impl Into<Value>) -> Self {
60 self.push_field(value);
61 self
62 }
63
64 pub fn push_field(&mut self, value: impl Into<Value>) {
65 self.fields.push(value.into());
66 }
67}
68
69impl Tuple for TupleValue {
70 fn field_at(&self, index: usize) -> Option<&dyn Reflect> {
71 Some(self.fields.get(index)?.as_reflect())
72 }
73
74 fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
75 Some(self.fields.get_mut(index)?.as_reflect_mut())
76 }
77
78 fn fields(&self) -> Iter<'_> {
79 Iter::new(self)
80 }
81
82 fn fields_mut(&mut self) -> ValueIterMut<'_> {
83 let iter = self.fields.iter_mut().map(|value| value.as_reflect_mut());
84 Box::new(iter)
85 }
86
87 fn fields_len(&self) -> usize {
88 self.fields.len()
89 }
90}
91
92impl DescribeType for TupleValue {
93 fn build(graph: &mut TypeGraph) -> NodeId {
94 graph.get_or_build_node_with::<Self, _>(|graph| {
95 OpaqueNode::new::<Self>(Default::default(), graph)
96 })
97 }
98}
99
100impl Reflect for TupleValue {
101 trivial_reflect_methods!();
102
103 fn patch(&mut self, value: &dyn Reflect) {
104 if let Some(tuple) = value.reflect_ref().as_tuple() {
105 for (index, value) in self.fields_mut().enumerate() {
106 if let Some(new_value) = tuple.field_at(index) {
107 value.patch(new_value);
108 }
109 }
110 }
111 }
112
113 fn to_value(&self) -> Value {
114 self.clone().into()
115 }
116
117 fn clone_reflect(&self) -> Box<dyn Reflect> {
118 Box::new(self.clone())
119 }
120
121 fn debug(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
122 if f.alternate() {
123 write!(f, "{self:#?}")
124 } else {
125 write!(f, "{self:?}")
126 }
127 }
128
129 fn reflect_owned(self: Box<Self>) -> ReflectOwned {
130 ReflectOwned::Tuple(self)
131 }
132
133 fn reflect_ref(&self) -> ReflectRef<'_> {
134 ReflectRef::Tuple(self)
135 }
136
137 fn reflect_mut(&mut self) -> ReflectMut<'_> {
138 ReflectMut::Tuple(self)
139 }
140}
141
142impl FromReflect for TupleValue {
143 fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
144 let tuple = reflect.reflect_ref().as_tuple()?;
145 let this = tuple
146 .fields()
147 .fold(TupleValue::default(), |builder, value| {
148 builder.with_field(value.to_value())
149 });
150 Some(this)
151 }
152}
153
154macro_rules! impl_tuple {
155 ($($ident:ident),* $(,)?) => {
156 #[allow(non_snake_case, unused_mut, unused_variables)]
157 impl<$($ident,)*> DescribeType for ($($ident,)*)
158 where
159 $($ident: Reflect + DescribeType + Clone,)*
160 {
161 fn build(graph: &mut TypeGraph) -> NodeId {
162 graph.get_or_build_node_with::<Self, _>(|graph| {
163 let fields = &[
164 $(
165 UnnamedFieldNode::new::<$ident>(Default::default(), Default::default(), graph),
166 )*
167 ];
168 TupleNode::new::<Self>(fields, Default::default(), Default::default())
169 })
170 }
171 }
172
173 #[allow(non_snake_case, unused_mut, unused_variables)]
174 impl<$($ident,)*> Reflect for ($($ident,)*)
175 where
176 $($ident: Reflect + DescribeType + Clone,)*
177 {
178 trivial_reflect_methods!();
179
180 #[allow(unused_assignments)]
181 fn patch(&mut self, value: &dyn Reflect) {
182 if let Some(tuple) = value.reflect_ref().as_tuple() {
183 let ($($ident,)*) = self;
184 let mut i = 0;
185 $(
186 if let Some(field) = tuple.field_at(i) {
187 $ident.patch(field);
188 }
189 i += 1;
190 )*
191 }
192 }
193
194 fn to_value(&self) -> Value {
195 let ($($ident,)*) = self;
196 let mut value = TupleValue::new();
197 $(
198 value = value.with_field($ident.to_value());
199 )*
200 value.into()
201 }
202
203 fn clone_reflect(&self) -> Box<dyn Reflect> {
204 Box::new(self.clone())
205 }
206
207 fn debug(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
208 write!(f, "{}", core::any::type_name::<Self>())
209 }
210
211 fn reflect_owned(self: Box<Self>) -> ReflectOwned {
212 ReflectOwned::Tuple(self)
213 }
214
215 fn reflect_ref(&self) -> ReflectRef<'_> {
216 ReflectRef::Tuple(self)
217 }
218
219 fn reflect_mut(&mut self) -> ReflectMut<'_> {
220 ReflectMut::Tuple(self)
221 }
222 }
223
224 #[allow(non_snake_case, unused_mut, unused_assignments, unused_variables)]
225 impl<$($ident,)*> Tuple for ($($ident,)*)
226 where
227 $($ident: Reflect + DescribeType + Clone,)*
228 {
229 fn field_at(&self, index: usize) -> Option<&dyn Reflect> {
230 let mut i = 0;
231 let ($($ident,)*) = self;
232 $(
233 if index == i {
234 return Some($ident);
235 }
236 i += 1;
237 )*
238 None
239 }
240
241 fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
242 let mut i = 0;
243 let ($($ident,)*) = self;
244 $(
245 if index == i {
246 return Some($ident);
247 }
248 i += 1;
249 )*
250 None
251 }
252
253 fn fields(&self) -> Iter<'_> {
254 Iter::new(self)
255 }
256
257 fn fields_mut(&mut self) -> ValueIterMut<'_> {
258 let ($($ident,)*) = self;
259 Box::new([$($ident.as_reflect_mut(),)*].into_iter())
260 }
261
262 fn fields_len(&self) -> usize {
263 let mut n = 0;
264 $(
265 let _ = stringify!($ident);
266 n += 1;
267 )*
268 n
269 }
270 }
271
272 #[allow(non_snake_case, unused_mut, unused_assignments, unused_variables)]
273 impl<$($ident,)*> FromReflect for ($($ident,)*)
274 where
275 $($ident: FromReflect + DescribeType + Clone,)*
276 {
277 fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
278 let tuple = reflect.as_tuple()?;
279 let mut fields = tuple.fields();
280 Some((
281 $($ident::from_reflect(fields.next()?)?,)*
282 ))
283 }
284 }
285 };
286}
287
288impl_tuple!();
289impl_tuple!(T1);
290impl_tuple!(T1, T2);
291impl_tuple!(T1, T2, T3);
292impl_tuple!(T1, T2, T3, T4);
293impl_tuple!(T1, T2, T3, T4, T5);
294impl_tuple!(T1, T2, T3, T4, T5, T6);
295impl_tuple!(T1, T2, T3, T4, T5, T6, T7);
296impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8);
297impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9);
298impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
299impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
300impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12);
301impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13);
302impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14);
303impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15);
304impl_tuple!(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16);
305
306impl<V> FromIterator<V> for TupleValue
307where
308 V: Reflect,
309{
310 fn from_iter<T>(iter: T) -> Self
311 where
312 T: IntoIterator<Item = V>,
313 {
314 let mut out = Self::default();
315 for value in iter {
316 out.push_field(value.to_value());
317 }
318 out
319 }
320}
321
322#[derive(Debug)]
323pub struct Iter<'a> {
324 tuple: &'a dyn Tuple,
325 index: usize,
326}
327
328impl<'a> Iter<'a> {
329 pub fn new(tuple: &'a dyn Tuple) -> Self {
330 Self { tuple, index: 0 }
331 }
332}
333
334impl<'a> Iterator for Iter<'a> {
335 type Item = &'a dyn Reflect;
336
337 fn next(&mut self) -> Option<Self::Item> {
338 let value = self.tuple.field_at(self.index)?;
339 self.index += 1;
340 Some(value)
341 }
342}
343
344impl<'a> ExactSizeIterator for Iter<'a> {
345 fn len(&self) -> usize {
346 self.tuple.fields_len()
347 }
348}
349
350impl<'a> FusedIterator for Iter<'a> {}