1use std::{
2 any::{type_name, type_name_of_val, TypeId},
3};
4use crate::{ReflectError, StructType};
5pub trait Reflect: Sized {
6 fn amount_of_fields(&self) -> usize;
7
8 fn try_get_index_of_field(&self, field_name: &str) -> Result<usize, ReflectError>;
9 fn get_index_of_field(&self, field_name: &str) -> usize {
10 self.try_get_index_of_field(field_name).expect(&format!(
11 "There is no field '{}' in {}",
12 field_name,
13 type_name::<Self>()
14 ))
15 }
16 fn try_get_field_at<T: 'static>(&self, field_index: usize) -> Result<&T, ReflectError>;
17 fn try_get_field_mut_at<T: 'static>(
18 &mut self,
19 field_index: usize,
20 ) -> Result<&mut T, ReflectError>;
21 fn try_set_field_at<T: 'static>(
22 &mut self,
23 field_index: usize,
24 new_field_value: T,
25 ) -> Result<(), ReflectError> {
26 let field_mut = self.try_get_field_mut_at(field_index)?;
27 *field_mut = new_field_value;
28 Ok(())
29 }
30 fn try_get_type_of_field_at(&self, field_index: usize) -> Result<TypeId, ReflectError>;
31
32 fn get_field_at<T: 'static>(&self, field_index: usize) -> &T {
33 match self.try_get_field_at(field_index) {
34 Ok(field_value) => field_value,
35 Err(ReflectError::WrongType) => panic!(
36 "The type of the field at {} is not {} in {}",
37 field_index,
38 type_name::<T>(),
39 type_name_of_val(self)
40 ),
41 Err(ReflectError::FieldNotFound) => panic!(
42 "There is no field at {} in {}",
43 field_index,
44 type_name_of_val(self)
45 ),
46 Err(ReflectError::EnumMemberNotFound) => unreachable!(),
47 }
48 }
49 fn get_field_mut_at<T: 'static>(&mut self, field_index: usize) -> &mut T {
50 let type_name_of_self = type_name_of_val(self);
51 match self.try_get_field_mut_at(field_index) {
52 Ok(field_value) => field_value,
53 Err(ReflectError::WrongType) => panic!(
54 "The type of the field at {} is not {} in {}",
55 field_index,
56 type_name::<T>(),
57 type_name_of_self
58 ),
59 Err(ReflectError::FieldNotFound) => panic!(
60 "There is no field at {} in {}",
61 field_index, type_name_of_self
62 ),
63 Err(ReflectError::EnumMemberNotFound) => unreachable!(),
64 }
65 }
66 fn set_field_at<T: 'static>(&mut self, field_index: usize, new_field_value: T) {
67 match self.try_set_field_at(field_index, new_field_value) {
68 Ok(()) => (),
69 Err(ReflectError::WrongType) => panic!(
70 "The type of the field at {} is not {} in {}",
71 field_index,
72 type_name::<T>(),
73 type_name_of_val(self)
74 ),
75 Err(ReflectError::FieldNotFound) => panic!(
76 "There is no field at {} in {}",
77 field_index,
78 type_name_of_val(self)
79 ),
80 Err(ReflectError::EnumMemberNotFound) => unreachable!(),
81 }
82 }
83 fn get_type_of_field_at(&self, field_index: usize) -> TypeId {
84 match self.try_get_type_of_field_at(field_index) {
85 Ok(type_id) => type_id,
86 Err(ReflectError::WrongType) => unreachable!(),
87 Err(ReflectError::FieldNotFound) => panic!(
88 "There is no field at {} in {}",
89 field_index,
90 type_name_of_val(self)
91 ),
92 Err(ReflectError::EnumMemberNotFound) => unreachable!(),
93 }
94 }
95
96 fn try_get_field<T: 'static>(&self, field_name: &'static str) -> Result<&T, ReflectError> {
97 let field_index = self.try_get_index_of_field(field_name)?;
98 self.try_get_field_at(field_index)
99 }
100 fn try_get_field_mut<T: 'static>(
101 &mut self,
102 field_name: &'static str,
103 ) -> Result<&mut T, ReflectError> {
104 let field_index = self.try_get_index_of_field(field_name)?;
105 self.try_get_field_mut_at(field_index)
106 }
107 fn try_set_field<T: 'static>(
108 &mut self,
109 field_name: &'static str,
110 new_field_value: T,
111 ) -> Result<(), ReflectError> {
112 let field_index = self.try_get_index_of_field(field_name)?;
113 self.try_set_field_at(field_index, new_field_value)
114 }
115 fn try_get_type_of_field(&self, field_name: &'static str) -> Result<TypeId, ReflectError> {
116 let field_index = self.try_get_index_of_field(field_name)?;
117 self.try_get_type_of_field_at(field_index)
118 }
119 fn get_field<T: 'static>(&self, field_name: &'static str) -> &T {
120 let field_index = self.get_index_of_field(field_name);
121 self.get_field_at(field_index)
122 }
123 fn get_field_mut<T: 'static>(&mut self, field_name: &'static str) -> &mut T {
124 let field_index = self.get_index_of_field(field_name);
125 self.get_field_mut_at(field_index)
126 }
127 fn set_field<T: 'static>(&mut self, field_name: &'static str, new_field_value: T) -> () {
128 let field_index = self.get_index_of_field(field_name);
129 self.set_field_at(field_index, new_field_value)
130 }
131 fn get_type_of_field(&self, field_name: &'static str) -> TypeId {
132 let field_index = self.get_index_of_field(field_name);
133 self.get_type_of_field_at(field_index)
134 }
135
136 fn has_field(&self, field_name: &str) -> bool {
137 self.try_get_index_of_field(field_name).is_ok()
138 }
139 fn has_field_at(&self, field_index: usize) -> bool {
140 field_index < self.amount_of_fields()
141 }
142}
143
144pub trait StructReflect {
145 const TYPE: StructType;
146 const FIELD_NAMES: &'static [&'static str];
147 fn try_get_index_of_field(field_name: &str) -> Result<usize, ReflectError>;
148 fn get_index_of_field(field_name: &str) -> usize {
149 Self::try_get_index_of_field(field_name).expect(&format!(
150 "There is no field '{}' in {}",
151 field_name,
152 type_name::<Self>()
153 ))
154 }
155}
156
157pub trait EnumReflect {
158 const MEMBER_NAMES: &'static [&'static str];
159 const MEMBER_TYPES: &'static [StructType];
160 fn get_index_of_member(member_name: &str) -> Result<usize, ReflectError>;
161}