1use core::{
2 any::Any,
3 fmt::Display,
4 num::NonZero,
5 ops::{Deref, DerefMut},
6};
7
8use serde::{Deserialize, Deserializer, Serialize, Serializer};
9
10use crate::{Error, Keys, Traversal, TreeAny, TreeDeserialize, TreeKey, TreeSerialize, Walk};
11
12#[derive(
23 Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
24)]
25#[serde(transparent)]
26#[repr(transparent)]
27pub struct Leaf<T: ?Sized>(pub T);
28
29impl<T: ?Sized> Deref for Leaf<T> {
30 type Target = T;
31 #[inline]
32 fn deref(&self) -> &Self::Target {
33 &self.0
34 }
35}
36
37impl<T: ?Sized> DerefMut for Leaf<T> {
38 #[inline]
39 fn deref_mut(&mut self) -> &mut Self::Target {
40 &mut self.0
41 }
42}
43
44impl<T> Leaf<T> {
45 #[inline]
47 pub fn into_inner(self) -> T {
48 self.0
49 }
50}
51
52impl<T> From<T> for Leaf<T> {
53 #[inline]
54 fn from(value: T) -> Self {
55 Self(value)
56 }
57}
58
59impl<T: Display> Display for Leaf<T> {
60 #[inline]
61 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
62 self.0.fmt(f)
63 }
64}
65
66impl<T: ?Sized> TreeKey for Leaf<T> {
67 #[inline]
68 fn traverse_all<W: Walk>() -> W {
69 W::leaf()
70 }
71
72 #[inline]
73 fn traverse_by_key<K, F, E>(mut keys: K, _func: F) -> Result<usize, Error<E>>
74 where
75 K: Keys,
76 F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
77 {
78 keys.finalize()?;
79 Ok(0)
80 }
81}
82
83impl<T: Serialize + ?Sized> TreeSerialize for Leaf<T> {
84 #[inline]
85 fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
86 where
87 K: Keys,
88 S: Serializer,
89 {
90 keys.finalize()?;
91 self.0.serialize(ser).map_err(|err| Error::Inner(0, err))
92 }
93}
94
95impl<'de, T: Deserialize<'de>> TreeDeserialize<'de> for Leaf<T> {
96 #[inline]
97 fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
98 where
99 K: Keys,
100 D: Deserializer<'de>,
101 {
102 keys.finalize()?;
103 self.0 = T::deserialize(de).map_err(|err| Error::Inner(0, err))?;
104 Ok(())
105 }
106
107 #[inline]
108 fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
109 where
110 K: Keys,
111 D: Deserializer<'de>,
112 {
113 keys.finalize()?;
114 T::deserialize(de).map_err(|err| Error::Inner(0, err))?;
115 Ok(())
116 }
117}
118
119impl<T: Any> TreeAny for Leaf<T> {
120 #[inline]
121 fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
122 where
123 K: Keys,
124 {
125 keys.finalize()?;
126 Ok(&self.0)
127 }
128
129 #[inline]
130 fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
131 where
132 K: Keys,
133 {
134 keys.finalize()?;
135 Ok(&mut self.0)
136 }
137}
138
139#[derive(
170 Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
171)]
172#[serde(transparent)]
173#[repr(transparent)]
174pub struct StrLeaf<T: ?Sized>(pub T);
175
176impl<T: ?Sized> Deref for StrLeaf<T> {
177 type Target = T;
178 #[inline]
179 fn deref(&self) -> &Self::Target {
180 &self.0
181 }
182}
183
184impl<T: ?Sized> DerefMut for StrLeaf<T> {
185 #[inline]
186 fn deref_mut(&mut self) -> &mut Self::Target {
187 &mut self.0
188 }
189}
190
191impl<T> StrLeaf<T> {
192 #[inline]
194 pub fn into_inner(self) -> T {
195 self.0
196 }
197}
198
199impl<T> From<T> for StrLeaf<T> {
200 #[inline]
201 fn from(value: T) -> Self {
202 Self(value)
203 }
204}
205
206impl<T: ?Sized> TreeKey for StrLeaf<T> {
207 #[inline]
208 fn traverse_all<W: Walk>() -> W {
209 W::leaf()
210 }
211
212 #[inline]
213 fn traverse_by_key<K, F, E>(mut keys: K, _func: F) -> Result<usize, Error<E>>
214 where
215 K: Keys,
216 F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
217 {
218 keys.finalize()?;
219 Ok(0)
220 }
221}
222
223impl<T: AsRef<str> + ?Sized> TreeSerialize for StrLeaf<T> {
224 #[inline]
225 fn serialize_by_key<K, S>(&self, mut keys: K, ser: S) -> Result<S::Ok, Error<S::Error>>
226 where
227 K: Keys,
228 S: Serializer,
229 {
230 keys.finalize()?;
231 let name = self.0.as_ref();
232 name.serialize(ser).map_err(|err| Error::Inner(0, err))
233 }
234}
235
236impl<'de, T: TryFrom<&'de str>> TreeDeserialize<'de> for StrLeaf<T> {
237 #[inline]
238 fn deserialize_by_key<K, D>(&mut self, mut keys: K, de: D) -> Result<(), Error<D::Error>>
239 where
240 K: Keys,
241 D: Deserializer<'de>,
242 {
243 keys.finalize()?;
244 let name = Deserialize::deserialize(de).map_err(|err| Error::Inner(0, err))?;
245 self.0 = T::try_from(name).or(Err(Traversal::Access(0, "Could not convert from str")))?;
246 Ok(())
247 }
248
249 #[inline]
250 fn probe_by_key<K, D>(mut keys: K, de: D) -> Result<(), Error<D::Error>>
251 where
252 K: Keys,
253 D: Deserializer<'de>,
254 {
255 keys.finalize()?;
256 let name = Deserialize::deserialize(de).map_err(|err| Error::Inner(0, err))?;
257 T::try_from(name).or(Err(Traversal::Access(0, "Could not convert from str")))?;
258 Ok(())
259 }
260}
261
262impl<T> TreeAny for StrLeaf<T> {
263 #[inline]
264 fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
265 where
266 K: Keys,
267 {
268 keys.finalize()?;
269 Err(Traversal::Access(0, "No Any access for StrLeaf"))
270 }
271
272 #[inline]
273 fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
274 where
275 K: Keys,
276 {
277 keys.finalize()?;
278 Err(Traversal::Access(0, "No Any access for StrLeaf"))
279 }
280}
281
282impl<T: Display> Display for StrLeaf<T> {
283 #[inline]
284 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
285 self.0.fmt(f)
286 }
287}
288
289#[derive(
291 Clone, Copy, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Deserialize, Serialize,
292)]
293#[serde(transparent)]
294#[repr(transparent)]
295pub struct Deny<T: ?Sized>(pub T);
296
297impl<T: ?Sized> Deref for Deny<T> {
298 type Target = T;
299 #[inline]
300 fn deref(&self) -> &Self::Target {
301 &self.0
302 }
303}
304
305impl<T: ?Sized> DerefMut for Deny<T> {
306 #[inline]
307 fn deref_mut(&mut self) -> &mut Self::Target {
308 &mut self.0
309 }
310}
311
312impl<T> Deny<T> {
313 #[inline]
315 pub fn into_inner(self) -> T {
316 self.0
317 }
318}
319
320impl<T> From<T> for Deny<T> {
321 #[inline]
322 fn from(value: T) -> Self {
323 Self(value)
324 }
325}
326
327impl<T: ?Sized> TreeKey for Deny<T> {
328 #[inline]
329 fn traverse_all<W: Walk>() -> W {
330 W::leaf()
331 }
332
333 #[inline]
334 fn traverse_by_key<K, F, E>(mut keys: K, _func: F) -> Result<usize, Error<E>>
335 where
336 K: Keys,
337 F: FnMut(usize, Option<&'static str>, NonZero<usize>) -> Result<(), E>,
338 {
339 keys.finalize()?;
340 Ok(0)
341 }
342}
343
344impl<T: ?Sized> TreeSerialize for Deny<T> {
345 #[inline]
346 fn serialize_by_key<K, S>(&self, mut keys: K, _ser: S) -> Result<S::Ok, Error<S::Error>>
347 where
348 K: Keys,
349 S: Serializer,
350 {
351 keys.finalize()?;
352 Err(Traversal::Access(0, "Denied").into())
353 }
354}
355
356impl<'de, T: ?Sized> TreeDeserialize<'de> for Deny<T> {
357 #[inline]
358 fn deserialize_by_key<K, D>(&mut self, mut keys: K, _de: D) -> Result<(), Error<D::Error>>
359 where
360 K: Keys,
361 D: Deserializer<'de>,
362 {
363 keys.finalize()?;
364 Err(Traversal::Access(0, "Denied").into())
365 }
366
367 #[inline]
368 fn probe_by_key<K, D>(mut keys: K, _de: D) -> Result<(), Error<D::Error>>
369 where
370 K: Keys,
371 D: Deserializer<'de>,
372 {
373 keys.finalize()?;
374 Err(Traversal::Access(0, "Denied").into())
375 }
376}
377
378impl<T> TreeAny for Deny<T> {
379 #[inline]
380 fn ref_any_by_key<K>(&self, mut keys: K) -> Result<&dyn Any, Traversal>
381 where
382 K: Keys,
383 {
384 keys.finalize()?;
385 Err(Traversal::Access(0, "Denied"))
386 }
387
388 #[inline]
389 fn mut_any_by_key<K>(&mut self, mut keys: K) -> Result<&mut dyn Any, Traversal>
390 where
391 K: Keys,
392 {
393 keys.finalize()?;
394 Err(Traversal::Access(0, "Denied"))
395 }
396}