fyrox_core/reflect/
std_impls.rs

1// Copyright (c) 2019-present Dmitry Stepanov and Fyrox Engine contributors.
2//
3// Permission is hereby granted, free of charge, to any person obtaining a copy
4// of this software and associated documentation files (the "Software"), to deal
5// in the Software without restriction, including without limitation the rights
6// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7// copies of the Software, and to permit persons to whom the Software is
8// furnished to do so, subject to the following conditions:
9//
10// The above copyright notice and this permission notice shall be included in all
11// copies or substantial portions of the Software.
12//
13// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19// SOFTWARE.
20
21//! `Reflect` implementations for `std` types
22
23use crate::{
24    delegate_reflect,
25    reflect::{blank_reflect, prelude::*},
26    sstorage::ImmutableString,
27    uuid::Uuid,
28};
29use fyrox_core_derive::impl_reflect;
30use std::{
31    any::Any,
32    cell::{Cell, RefCell},
33    collections::HashMap,
34    fmt::Debug,
35    hash::{BuildHasher, Hash},
36    ops::{Deref, DerefMut, Range},
37    rc::Rc,
38    sync::Arc,
39    time::{Duration, Instant},
40};
41
42macro_rules! impl_blank_reflect {
43    ( $( $ty:ty ),* $(,)? ) => {
44        $(
45            impl Reflect for $ty {
46                blank_reflect!();
47            }
48        )*
49    }
50}
51
52impl_blank_reflect! {
53    f32, f64,
54    usize, u8, u16, u32, u64,
55    isize, i8, i16, i32, i64,
56    bool, char,
57    String,
58    std::path::PathBuf,
59    Duration, Instant,
60    ImmutableString
61}
62
63macro_rules! impl_reflect_tuple {
64    (
65        $(
66            ( $($t:ident,)* );
67        )*
68    ) => {
69        $(
70            impl< $($t: Reflect),* > Reflect for ( $($t,)* ) {
71                blank_reflect!();
72            }
73        )*
74    }
75}
76
77impl_reflect_tuple! {
78    (T0,);
79    (T0, T1, );
80    (T0, T1, T2, );
81    (T0, T1, T2, T3,);
82    (T0, T1, T2, T3, T4,);
83}
84
85impl<const N: usize, T: Reflect> Reflect for [T; N] {
86    blank_reflect!();
87
88    fn as_array(&self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
89        func(Some(self))
90    }
91
92    fn as_array_mut(&mut self, func: &mut dyn FnMut(Option<&mut dyn ReflectArray>)) {
93        func(Some(self))
94    }
95}
96
97impl<const N: usize, T: Reflect> ReflectArray for [T; N] {
98    fn reflect_index(&self, index: usize) -> Option<&dyn Reflect> {
99        if let Some(item) = self.get(index) {
100            Some(item)
101        } else {
102            None
103        }
104    }
105
106    fn reflect_index_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
107        if let Some(item) = self.get_mut(index) {
108            Some(item)
109        } else {
110            None
111        }
112    }
113
114    fn reflect_len(&self) -> usize {
115        self.len()
116    }
117}
118
119impl_reflect! {
120    #[reflect(ReflectList, ReflectArray)]
121    pub struct Vec<T: Reflect + 'static>;
122}
123
124impl<T: Reflect + 'static> ReflectArray for Vec<T> {
125    fn reflect_index(&self, index: usize) -> Option<&dyn Reflect> {
126        self.get(index).map(|x| x as &dyn Reflect)
127    }
128
129    fn reflect_index_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
130        self.get_mut(index).map(|x| x as &mut dyn Reflect)
131    }
132
133    fn reflect_len(&self) -> usize {
134        self.len()
135    }
136}
137
138/// REMARK: `Reflect` is implemented for `Vec<T>` where `T: Reflect` only.
139impl<T: Reflect + 'static> ReflectList for Vec<T> {
140    fn reflect_push(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
141        self.push(*value.downcast::<T>()?);
142        Ok(())
143    }
144
145    fn reflect_pop(&mut self) -> Option<Box<dyn Reflect>> {
146        if let Some(item) = self.pop() {
147            Some(Box::new(item))
148        } else {
149            None
150        }
151    }
152
153    fn reflect_remove(&mut self, index: usize) -> Option<Box<dyn Reflect>> {
154        if index < self.len() {
155            Some(Box::new(self.remove(index)))
156        } else {
157            None
158        }
159    }
160
161    fn reflect_insert(
162        &mut self,
163        index: usize,
164        value: Box<dyn Reflect>,
165    ) -> Result<(), Box<dyn Reflect>> {
166        self.insert(index, *value.downcast::<T>()?);
167        Ok(())
168    }
169}
170
171impl<K, V, S> Reflect for HashMap<K, V, S>
172where
173    K: Reflect + Debug + Eq + Hash + 'static,
174    V: Reflect + Debug + 'static,
175    S: BuildHasher + 'static,
176{
177    blank_reflect!();
178
179    fn as_hash_map(&self, func: &mut dyn FnMut(Option<&dyn ReflectHashMap>)) {
180        func(Some(self))
181    }
182
183    fn as_hash_map_mut(&mut self, func: &mut dyn FnMut(Option<&mut dyn ReflectHashMap>)) {
184        func(Some(self))
185    }
186}
187
188impl<K, V, S> ReflectHashMap for HashMap<K, V, S>
189where
190    K: Reflect + Debug + Eq + Hash + 'static,
191    V: Reflect + Debug + 'static,
192    S: BuildHasher + 'static,
193{
194    fn reflect_insert(
195        &mut self,
196        key: Box<dyn Reflect>,
197        value: Box<dyn Reflect>,
198    ) -> Option<Box<dyn Reflect>> {
199        if let Ok(key) = key.downcast::<K>() {
200            if let Ok(value) = value.downcast::<V>() {
201                if let Some(previous) = self.insert(*key, *value) {
202                    return Some(Box::new(previous));
203                }
204            }
205        }
206
207        None
208    }
209
210    fn reflect_len(&self) -> usize {
211        self.len()
212    }
213
214    fn reflect_get(&self, key: &dyn Reflect, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
215        key.downcast_ref::<K>(&mut |result| match result {
216            Some(key) => match self.get(key) {
217                Some(value) => func(Some(value as &dyn Reflect)),
218                None => func(None),
219            },
220            None => func(None),
221        })
222    }
223
224    fn reflect_get_mut(
225        &mut self,
226        key: &dyn Reflect,
227        func: &mut dyn FnMut(Option<&mut dyn Reflect>),
228    ) {
229        key.downcast_ref::<K>(&mut |result| match result {
230            Some(key) => match self.get_mut(key) {
231                Some(value) => func(Some(value as &mut dyn Reflect)),
232                None => func(None),
233            },
234            None => func(None),
235        })
236    }
237
238    fn reflect_get_nth_value_ref(&self, index: usize) -> Option<&dyn Reflect> {
239        self.values().nth(index).map(|v| v as &dyn Reflect)
240    }
241
242    fn reflect_get_nth_value_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
243        self.values_mut().nth(index).map(|v| v as &mut dyn Reflect)
244    }
245
246    fn reflect_get_at(&self, index: usize) -> Option<(&dyn Reflect, &dyn Reflect)> {
247        self.iter()
248            .nth(index)
249            .map(|(k, v)| (k as &dyn Reflect, v as &dyn Reflect))
250    }
251
252    fn reflect_get_at_mut(&mut self, index: usize) -> Option<(&dyn Reflect, &mut dyn Reflect)> {
253        self.iter_mut()
254            .nth(index)
255            .map(|(k, v)| (k as &dyn Reflect, v as &mut dyn Reflect))
256    }
257
258    fn reflect_remove(
259        &mut self,
260        key: &dyn Reflect,
261        func: &mut dyn FnMut(Option<Box<dyn Reflect>>),
262    ) {
263        key.downcast_ref::<K>(&mut |result| match result {
264            Some(key) => func(
265                self.remove(key)
266                    .map(|value| Box::new(value) as Box<dyn Reflect>),
267            ),
268            None => func(None),
269        })
270    }
271}
272
273impl Reflect for () {
274    blank_reflect!();
275}
276
277impl_reflect! { pub struct Uuid; }
278
279impl_reflect! {
280    pub struct Cell<T: Debug + Copy>;
281}
282
283impl_reflect! {
284    pub enum Option<T> {
285        Some(T),
286        None
287    }
288}
289
290impl_reflect! {
291    pub struct Range<Idx> {
292        pub start: Idx,
293        pub end: Idx,
294    }
295}
296
297impl<T: ?Sized + Reflect> Reflect for Box<T> {
298    delegate_reflect!();
299}
300
301macro_rules! impl_reflect_inner_mutability {
302    ($self:ident, $acquire_lock_guard:block, $into_inner:block) => {
303        fn source_path() -> &'static str {
304            file!()
305        }
306
307        fn type_name(&$self) -> &'static str {
308            std::any::type_name::<T>()
309        }
310
311        fn doc(&$self) -> &'static str {
312            ""
313        }
314
315        fn assembly_name(&self) -> &'static str {
316            env!("CARGO_PKG_NAME")
317        }
318
319        fn type_assembly_name() -> &'static str {
320            env!("CARGO_PKG_NAME")
321        }
322
323        fn fields_info(&$self, func: &mut dyn FnMut(&[FieldInfo])) {
324            let guard = $acquire_lock_guard;
325            guard.fields_info(func)
326        }
327
328        fn into_any($self: Box<Self>) -> Box<dyn Any> {
329            let inner = $into_inner;
330            Box::new(inner)
331        }
332
333        fn as_any(&$self, func: &mut dyn FnMut(&dyn Any)) {
334            let guard = $acquire_lock_guard;
335            (*guard).as_any(func)
336        }
337
338        fn as_any_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Any)) {
339            let mut guard = $acquire_lock_guard;
340            (*guard).as_any_mut(func)
341        }
342
343        fn as_reflect(&$self, func: &mut dyn FnMut(&dyn Reflect)) {
344            let guard = $acquire_lock_guard;
345            (*guard).as_reflect(func)
346        }
347
348        fn as_reflect_mut(&mut $self, func: &mut dyn FnMut(&mut dyn Reflect)) {
349            let mut guard = $acquire_lock_guard;
350            (*guard).as_reflect_mut(func)
351        }
352
353        fn set(&mut $self, value: Box<dyn Reflect>) -> Result<Box<dyn Reflect>, Box<dyn Reflect>> {
354            let mut guard = $acquire_lock_guard;
355            guard.set(value)
356        }
357
358        fn set_field(
359            &mut $self,
360            field: &str,
361            value: Box<dyn Reflect>,
362            func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>),
363        ) {
364            let mut guard = $acquire_lock_guard;
365            guard.set_field(field, value, func)
366        }
367
368        fn fields(&$self, func: &mut dyn FnMut(&[&dyn Reflect])) {
369            let guard = $acquire_lock_guard;
370            guard.fields(func)
371        }
372
373        fn fields_mut(&mut $self, func: &mut dyn FnMut(&mut [&mut dyn Reflect])) {
374            let mut guard = $acquire_lock_guard;
375            guard.fields_mut(func)
376        }
377
378        fn field(&$self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>)) {
379            let guard = $acquire_lock_guard;
380            guard.field(name, func)
381        }
382
383        fn field_mut(&mut $self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>)) {
384            let mut guard = $acquire_lock_guard;
385            guard.field_mut(name, func)
386        }
387
388        fn as_array(&$self, func: &mut dyn FnMut(Option<&dyn ReflectArray>)) {
389            let guard = $acquire_lock_guard;
390            guard.as_array(func)
391        }
392
393        fn as_array_mut(&mut $self, func: &mut dyn FnMut(Option<&mut dyn ReflectArray>)) {
394            let mut guard = $acquire_lock_guard;
395            guard.as_array_mut(func)
396        }
397
398        fn as_list(&$self, func: &mut dyn FnMut(Option<&dyn ReflectList>)) {
399            let guard = $acquire_lock_guard;
400            guard.as_list(func)
401        }
402
403        fn as_list_mut(&mut $self, func: &mut dyn FnMut(Option<&mut dyn ReflectList>)) {
404            let mut guard = $acquire_lock_guard;
405            guard.as_list_mut(func)
406        }
407
408        fn as_inheritable_variable(
409            &$self,
410            func: &mut dyn FnMut(Option<&dyn ReflectInheritableVariable>),
411        ) {
412            let guard = $acquire_lock_guard;
413            guard.as_inheritable_variable(func)
414        }
415
416        fn as_inheritable_variable_mut(
417            &mut $self,
418            func: &mut dyn FnMut(Option<&mut dyn ReflectInheritableVariable>),
419        ) {
420            let mut guard = $acquire_lock_guard;
421            guard.as_inheritable_variable_mut(func)
422        }
423
424        fn as_hash_map(&$self, func: &mut dyn FnMut(Option<&dyn ReflectHashMap>)) {
425            let guard = $acquire_lock_guard;
426            guard.as_hash_map(func)
427        }
428
429        fn as_hash_map_mut(&mut $self, func: &mut dyn FnMut(Option<&mut dyn ReflectHashMap>)) {
430            let mut guard = $acquire_lock_guard;
431            guard.as_hash_map_mut(func)
432        }
433    };
434}
435
436impl<T: Reflect> Reflect for parking_lot::Mutex<T> {
437    impl_reflect_inner_mutability!(self, { self.lock() }, { self.into_inner() });
438}
439
440impl<T: Reflect> Reflect for parking_lot::RwLock<T> {
441    impl_reflect_inner_mutability!(self, { self.write() }, { self.into_inner() });
442}
443
444#[allow(clippy::mut_mutex_lock)]
445impl<T: Reflect> Reflect for std::sync::Mutex<T> {
446    impl_reflect_inner_mutability!(self, { self.lock().unwrap() }, { self.into_inner() });
447}
448
449impl<T: Reflect> Reflect for std::sync::RwLock<T> {
450    impl_reflect_inner_mutability!(self, { self.write().unwrap() }, { self.into_inner() });
451}
452
453impl<T: Reflect> Reflect for Arc<parking_lot::Mutex<T>> {
454    impl_reflect_inner_mutability!(self, { self.lock() }, {
455        Arc::into_inner(*self)
456            .expect("Value cannot be shared!")
457            .into_inner()
458    });
459}
460
461impl<T: Reflect> Reflect for Arc<std::sync::Mutex<T>> {
462    impl_reflect_inner_mutability!(self, { self.lock().unwrap() }, {
463        Arc::into_inner(*self)
464            .expect("Value cannot be shared!")
465            .into_inner()
466    });
467}
468
469impl<T: Reflect> Reflect for Arc<std::sync::RwLock<T>> {
470    impl_reflect_inner_mutability!(self, { self.write().unwrap() }, {
471        Arc::into_inner(*self)
472            .expect("Value cannot be shared!")
473            .into_inner()
474    });
475}
476
477impl<T: Reflect> Reflect for Arc<parking_lot::RwLock<T>> {
478    impl_reflect_inner_mutability!(self, { self.write() }, {
479        Arc::into_inner(*self)
480            .expect("Value cannot be shared!")
481            .into_inner()
482    });
483}
484
485impl<T: Reflect> Reflect for RefCell<T> {
486    impl_reflect_inner_mutability!(self, { self.borrow_mut() }, { self.into_inner() });
487}
488
489impl<T: Reflect> Reflect for Rc<RefCell<T>> {
490    impl_reflect_inner_mutability!(self, { self.borrow_mut() }, {
491        Rc::into_inner(*self)
492            .expect("Value cannot be shared!")
493            .into_inner()
494    });
495}
fyrox_core/reflect/std_impls.rs

fyrox_core/reflect/
std_impls.rs
