reflect/
data.rs

1use crate::{attr, Field, Fields, Value};
2use std::fmt;
3use std::fmt::Debug;
4use std::marker::PhantomData;
5use syn::Attribute;
6
7#[derive(Debug, Clone)]
8pub enum Data<T> {
9    Struct(Struct<T>),
10    Enum(Enum<T>),
11}
12
13impl<T> Data<T> {
14    pub fn attrs(&self) -> &[Attribute] {
15        match self {
16            Data::Struct(s) => s.attrs(),
17            Data::Enum(e) => &e.attrs,
18        }
19    }
20}
21
22#[derive(Debug, Clone)]
23pub enum Struct<T> {
24    Unit(UnitStruct),
25    Tuple(TupleStruct<T>),
26    Struct(StructStruct<T>),
27}
28
29impl<T> Struct<T> {
30    pub fn attrs(&self) -> &[Attribute] {
31        match self {
32            Struct::Unit(us) => &us.attrs,
33            Struct::Tuple(ts) => &ts.attrs,
34            Struct::Struct(ss) => &ss.attrs,
35        }
36    }
37}
38
39#[derive(Clone)]
40pub struct UnitStruct {
41    pub(crate) attrs: Vec<Attribute>,
42}
43
44impl Debug for UnitStruct {
45    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
46        f.debug_struct("UnitStruct")
47            .field("attrs", attr::debug(&self.attrs))
48            .finish()
49    }
50}
51
52#[derive(Clone)]
53pub struct TupleStruct<T> {
54    pub(crate) fields: Vec<Field<T>>,
55    pub(crate) attrs: Vec<Attribute>,
56}
57
58impl<T: Debug> Debug for TupleStruct<T> {
59    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
60        f.debug_struct("TupleStruct")
61            .field("fields", &self.fields)
62            .field("attrs", attr::debug(&self.attrs))
63            .finish()
64    }
65}
66
67#[derive(Clone)]
68pub struct StructStruct<T> {
69    pub(crate) fields: Vec<Field<T>>,
70    pub(crate) attrs: Vec<Attribute>,
71}
72
73impl<T: Debug> Debug for StructStruct<T> {
74    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
75        f.debug_struct("StructStruct")
76            .field("fields", &self.fields)
77            .field("attrs", attr::debug(&self.attrs))
78            .finish()
79    }
80}
81
82impl<T> Struct<T> {
83    pub fn fields(&self) -> Fields<T>
84    where
85        T: Clone,
86    {
87        let fields = match self {
88            Struct::Unit(s) => Vec::new(),
89            Struct::Tuple(s) => s.fields.clone(),
90            Struct::Struct(s) => s.fields.clone(),
91        };
92        Fields {
93            fields: fields.into_iter(),
94        }
95    }
96}
97
98impl<T> TupleStruct<T> {
99    pub fn fields(&self) -> Fields<T>
100    where
101        T: Clone,
102    {
103        Fields {
104            fields: self.fields.clone().into_iter(),
105        }
106    }
107
108    pub fn attrs(&self) -> &[Attribute] {
109        &self.attrs
110    }
111}
112
113impl<T> StructStruct<T> {
114    pub fn fields(&self) -> Fields<T>
115    where
116        T: Clone,
117    {
118        Fields {
119            fields: self.fields.clone().into_iter(),
120        }
121    }
122
123    pub fn attrs(&self) -> &[Attribute] {
124        &self.attrs
125    }
126}
127
128#[derive(Clone)]
129pub struct Enum<T> {
130    pub(crate) variants: Vec<Variant<T>>,
131    pub(crate) attrs: Vec<Attribute>,
132}
133
134impl<T: Debug> Debug for Enum<T> {
135    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
136        f.debug_struct("Enum")
137            .field("variants", &self.variants)
138            .field("attrs", attr::debug(&self.attrs))
139            .finish()
140    }
141}
142
143impl Enum<Value> {
144    pub fn match_variant<Run>(&self, run: Run) -> Value
145    where
146        Run: Fn(Variant<Value>) -> Value,
147    {
148        let mut arms = Vec::new();
149        for variant in self.variants.clone() {
150            arms.push(run(variant));
151        }
152        // FIXME introduce a match node
153        unimplemented!()
154    }
155
156    pub fn attrs(&self) -> &[Attribute] {
157        &self.attrs
158    }
159}
160
161#[derive(Debug, Clone)]
162pub enum Variant<T> {
163    Unit(UnitVariant),
164    Tuple(TupleVariant<T>),
165    Struct(StructVariant<T>),
166}
167
168impl<T> Variant<T> {
169    pub fn attrs(&self) -> &[Attribute] {
170        match self {
171            Variant::Unit(uv) => &uv.attrs,
172            Variant::Tuple(tv) => &tv.attrs,
173            Variant::Struct(sv) => &sv.attrs,
174        }
175    }
176}
177
178#[derive(Clone)]
179pub struct UnitVariant {
180    pub(crate) attrs: Vec<Attribute>,
181}
182
183impl Debug for UnitVariant {
184    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
185        f.debug_struct("UnitVariant")
186            .field("attrs", attr::debug(&self.attrs))
187            .finish()
188    }
189}
190
191#[derive(Clone)]
192pub struct TupleVariant<T> {
193    pub(crate) phantom: PhantomData<T>,
194    pub(crate) attrs: Vec<Attribute>,
195}
196
197impl<T: Debug> Debug for TupleVariant<T> {
198    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
199        f.debug_struct("TupleVariant")
200            .field("attrs", attr::debug(&self.attrs))
201            .finish()
202    }
203}
204
205#[derive(Clone)]
206pub struct StructVariant<T> {
207    pub(crate) phantom: PhantomData<T>,
208    pub(crate) attrs: Vec<Attribute>,
209}
210
211impl<T: Debug> Debug for StructVariant<T> {
212    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
213        f.debug_struct("StructVariant")
214            .field("attrs", attr::debug(&self.attrs))
215            .finish()
216    }
217}
reflect/data.rs

reflect/
data.rs
