1use crate::{Error, Result};
2
3pub const JSON_ATTR_MAX: usize = 31;
4pub const JSON_VAL_MAX: usize = 512;
5
6#[derive(Clone, Copy)]
7pub struct EnumValue<'a> {
8 pub name: &'a str,
9 pub value: i32,
10}
11
12#[derive(Clone, Copy)]
13pub enum DefaultValue<'a> {
14 None,
15 Integer(i32),
16 UInteger(u32),
17 Short(i16),
18 UShort(u16),
19 Real(f64),
20 Boolean(bool),
21 Character(u8),
22 Check(&'a str),
23}
24
25pub enum Target<'a, T> {
26 One(&'a mut T),
27 Many(&'a mut [T]),
28}
29
30impl<T: Copy> Target<'_, T> {
31 #[inline]
32 pub(crate) fn set(&mut self, offset: usize, value: T) -> Result<()> {
33 match self {
34 Target::One(target) if offset == 0 => {
35 **target = value;
36 Ok(())
37 }
38 Target::Many(targets) => {
39 *targets.get_mut(offset).ok_or(Error::SubTooLong)? = value;
40 Ok(())
41 }
42 Target::One(_) => Ok(()),
43 }
44 }
45}
46
47pub type TargetI32<'a> = Target<'a, i32>;
48pub type TargetU32<'a> = Target<'a, u32>;
49pub type TargetI16<'a> = Target<'a, i16>;
50pub type TargetU16<'a> = Target<'a, u16>;
51pub type TargetF64<'a> = Target<'a, f64>;
52pub type TargetBool<'a> = Target<'a, bool>;
53pub type TargetChar<'a> = Target<'a, u8>;
54
55pub enum AttrKind<'a> {
56 Integer(TargetI32<'a>),
57 UInteger(TargetU32<'a>),
58 Real(TargetF64<'a>),
59 String(&'a mut [u8]),
60 Boolean(TargetBool<'a>),
61 Character(TargetChar<'a>),
62 Time(TargetF64<'a>),
63 Object(&'a mut [Attr<'a>]),
64 Array(Array<'a>),
65 Check(&'a str),
66 Ignore,
67 Short(TargetI16<'a>),
68 UShort(TargetU16<'a>),
69}
70
71pub struct Attr<'a> {
72 pub name: &'a str,
73 pub kind: AttrKind<'a>,
74 pub default: DefaultValue<'a>,
75 pub map: Option<&'a [EnumValue<'a>]>,
76 pub nodefault: bool,
77}
78
79impl<'a> Attr<'a> {
80 #[inline]
81 pub fn integer(name: &'a str, target: &'a mut i32) -> Self {
82 Self::new(name, AttrKind::Integer(TargetI32::One(target)))
83 }
84
85 #[inline]
86 pub fn integers(name: &'a str, target: &'a mut [i32]) -> Self {
87 Self::new(name, AttrKind::Integer(TargetI32::Many(target)))
88 }
89
90 #[inline]
91 pub fn uinteger(name: &'a str, target: &'a mut u32) -> Self {
92 Self::new(name, AttrKind::UInteger(TargetU32::One(target)))
93 }
94
95 #[inline]
96 pub fn uintegers(name: &'a str, target: &'a mut [u32]) -> Self {
97 Self::new(name, AttrKind::UInteger(TargetU32::Many(target)))
98 }
99
100 #[inline]
101 pub fn short(name: &'a str, target: &'a mut i16) -> Self {
102 Self::new(name, AttrKind::Short(TargetI16::One(target)))
103 }
104
105 #[inline]
106 pub fn shorts(name: &'a str, target: &'a mut [i16]) -> Self {
107 Self::new(name, AttrKind::Short(TargetI16::Many(target)))
108 }
109
110 #[inline]
111 pub fn ushort(name: &'a str, target: &'a mut u16) -> Self {
112 Self::new(name, AttrKind::UShort(TargetU16::One(target)))
113 }
114
115 #[inline]
116 pub fn ushorts(name: &'a str, target: &'a mut [u16]) -> Self {
117 Self::new(name, AttrKind::UShort(TargetU16::Many(target)))
118 }
119}
120
121impl<'a> Attr<'a> {
122 #[inline]
123 pub fn real(name: &'a str, target: &'a mut f64) -> Self {
124 Self::new(name, AttrKind::Real(TargetF64::One(target)))
125 }
126
127 #[inline]
128 pub fn reals(name: &'a str, target: &'a mut [f64]) -> Self {
129 Self::new(name, AttrKind::Real(TargetF64::Many(target)))
130 }
131
132 #[inline]
133 pub fn string(name: &'a str, target: &'a mut [u8]) -> Self {
134 Self::new(name, AttrKind::String(target))
135 }
136
137 #[inline]
138 pub fn boolean(name: &'a str, target: &'a mut bool) -> Self {
139 Self::new(name, AttrKind::Boolean(TargetBool::One(target)))
140 }
141
142 #[inline]
143 pub fn booleans(name: &'a str, target: &'a mut [bool]) -> Self {
144 Self::new(name, AttrKind::Boolean(TargetBool::Many(target)))
145 }
146
147 #[inline]
148 pub fn character(name: &'a str, target: &'a mut u8) -> Self {
149 Self::new(name, AttrKind::Character(TargetChar::One(target)))
150 }
151
152 #[inline]
153 pub fn characters(name: &'a str, target: &'a mut [u8]) -> Self {
154 Self::new(name, AttrKind::Character(TargetChar::Many(target)))
155 }
156}
157
158impl<'a> Attr<'a> {
159 #[inline]
160 pub fn time(name: &'a str, target: &'a mut f64) -> Self {
161 Self::new(name, AttrKind::Time(TargetF64::One(target)))
162 }
163
164 #[inline]
165 pub fn object(name: &'a str, attrs: &'a mut [Attr<'a>]) -> Self {
166 Self::new(name, AttrKind::Object(attrs))
167 }
168
169 #[inline]
170 pub fn array(name: &'a str, array: Array<'a>) -> Self {
171 Self::new(name, AttrKind::Array(array))
172 }
173
174 #[inline]
175 pub fn check(name: &'a str, expected: &'a str) -> Self {
176 let mut attr = Self::new(name, AttrKind::Check(expected));
177 attr.default = DefaultValue::Check(expected);
178 attr
179 }
180
181 #[inline]
182 pub fn ignore_any() -> Self {
183 Self::new("", AttrKind::Ignore)
184 }
185
186 #[inline]
187 pub fn with_default(mut self, default: DefaultValue<'a>) -> Self {
188 self.default = default;
189 self
190 }
191
192 #[inline]
193 pub fn with_map(mut self, map: &'a [EnumValue<'a>]) -> Self {
194 self.map = Some(map);
195 self
196 }
197
198 #[inline]
199 pub fn nodefault(mut self) -> Self {
200 self.nodefault = true;
201 self
202 }
203
204 #[inline]
205 fn new(name: &'a str, kind: AttrKind<'a>) -> Self {
206 Self {
207 name,
208 kind,
209 default: DefaultValue::None,
210 map: None,
211 nodefault: false,
212 }
213 }
214}
215
216pub enum Array<'a> {
217 Strings {
218 store: &'a mut [&'a mut [u8]],
219 count: Option<&'a mut usize>,
220 },
221 Integers {
222 store: &'a mut [i32],
223 count: Option<&'a mut usize>,
224 },
225 UIntegers {
226 store: &'a mut [u32],
227 count: Option<&'a mut usize>,
228 },
229 Shorts {
230 store: &'a mut [i16],
231 count: Option<&'a mut usize>,
232 },
233 UShorts {
234 store: &'a mut [u16],
235 count: Option<&'a mut usize>,
236 },
237 Reals {
238 store: &'a mut [f64],
239 count: Option<&'a mut usize>,
240 },
241 Booleans {
242 store: &'a mut [bool],
243 count: Option<&'a mut usize>,
244 },
245 Objects {
246 attrs: &'a mut [Attr<'a>],
247 maxlen: usize,
248 count: Option<&'a mut usize>,
249 },
250 StructObjects {
251 maxlen: usize,
252 count: Option<&'a mut usize>,
253 parser: &'a mut dyn FnMut(&str, usize) -> Result<usize>,
254 },
255}