Skip to content

Commit 833ef96

Browse files
woshiluowoshiluo
committed
refactor: merge BorrowedValueDeserializer and StructDeserializer as ValueDeserializer
Signed-off-by: Woshiluo Luo <woshiluo.luo@outlook.com>
1 parent c88622a commit 833ef96

File tree

5 files changed

+262
-404
lines changed

5 files changed

+262
-404
lines changed

‎src/de_mut/data.rs‎

Lines changed: 171 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,62 @@
1-
use super::{DtError, PropCursor, RefDtb, RegConfig};
2-
use serde::de;
1+
use super::BodyCursor;
2+
use super::{DtError, PropCursor, RefDtb, RegConfig};
33

4-
pub(super) struct BorrowedValueDeserializer<'de> {
4+
use core::marker::PhantomData;
5+
use serde::{de, Deserialize};
6+
7+
#[derive(Clone, Debug)]
8+
pub(super) enum ValueCursor {
9+
Prop(PropCursor),
10+
Body(BodyCursor),
11+
}
12+
13+
#[derive(Clone)]
14+
pub(super) struct ValueDeserializer<'de> {
515
pub dtb: RefDtb<'de>,
616
pub reg: RegConfig,
7-
pub cursor: PropCursor,
17+
pub body_cursor: BodyCursor,
18+
pub cursor: ValueCursor,
819
}
920

10-
impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
21+
impl<'de> Deserialize<'de> for ValueDeserializer<'_> {
22+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
23+
where
24+
D: serde::Deserializer<'de>,
25+
{
26+
struct Visitor<'de, 'b> {
27+
marker: PhantomData<ValueDeserializer<'b>>,
28+
lifetime: PhantomData<&'de ()>,
29+
}
30+
impl<'de, 'b> de::Visitor<'de> for Visitor<'de, 'b> {
31+
type Value = ValueDeserializer<'b>;
32+
33+
fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
34+
write!(formatter, "struct ValueDeserializer")
35+
}
36+
37+
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
38+
where
39+
D: de::Deserializer<'de>,
40+
{
41+
Ok(unsafe {
42+
(*(core::ptr::addr_of!(deserializer) as *const _ as *const &ValueDeserializer))
43+
.clone()
44+
})
45+
}
46+
}
47+
48+
serde::Deserializer::deserialize_newtype_struct(
49+
deserializer,
50+
super::VALUE_DESERIALIZER_NAME,
51+
Visitor {
52+
marker: PhantomData,
53+
lifetime: PhantomData,
54+
},
55+
)
56+
}
57+
}
58+
59+
impl<'de> de::Deserializer<'de> for &mut ValueDeserializer<'de> {
1160
type Error = DtError;
1261

1362
fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
@@ -21,14 +70,17 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
2170
where
2271
V: de::Visitor<'de>,
2372
{
24-
let val = self.cursor.map_on(self.dtb, |data| {
25-
if data.is_empty() {
26-
true
27-
} else {
28-
todo!("&[u8] -> bool")
29-
}
30-
});
31-
visitor.visit_bool(val)
73+
if let ValueCursor::Prop(cursor) = self.cursor {
74+
let val = cursor.map_on(self.dtb, |data| {
75+
if data.is_empty() {
76+
true
77+
} else {
78+
todo!("&[u8] -> bool")
79+
}
80+
});
81+
return visitor.visit_bool(val);
82+
}
83+
unreachable!("Node -> bool");
3284
}
3385

3486
fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
@@ -77,7 +129,10 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
77129
where
78130
V: de::Visitor<'de>,
79131
{
80-
visitor.visit_u32(self.cursor.map_u32_on(self.dtb)?)
132+
if let ValueCursor::Prop(cursor) = self.cursor {
133+
return visitor.visit_u32(cursor.map_u32_on(self.dtb)?);
134+
}
135+
unreachable!("node -> u32");
81136
}
82137

83138
fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
@@ -108,12 +163,11 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
108163
unreachable!("char")
109164
}
110165

111-
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
166+
fn deserialize_str<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
112167
where
113168
V: de::Visitor<'de>,
114169
{
115-
let data = self.cursor.data_on(self.dtb);
116-
visitor.visit_borrowed_str(unsafe { core::str::from_utf8_unchecked(data) })
170+
unreachable!("str");
117171
}
118172

119173
fn deserialize_string<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
@@ -127,8 +181,11 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
127181
where
128182
V: de::Visitor<'de>,
129183
{
130-
let data = self.cursor.data_on(self.dtb);
131-
visitor.visit_borrowed_bytes(data)
184+
if let ValueCursor::Prop(cursor) = self.cursor {
185+
let data = cursor.data_on(self.dtb);
186+
return visitor.visit_borrowed_bytes(data);
187+
}
188+
unreachable!("node -> bytes");
132189
}
133190

134191
fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
@@ -142,11 +199,16 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
142199
where
143200
V: de::Visitor<'de>,
144201
{
145-
let data = self.cursor.data_on(self.dtb);
146-
if data.is_empty() {
147-
visitor.visit_none()
148-
} else {
149-
visitor.visit_some(self)
202+
match self.cursor {
203+
ValueCursor::Prop(cursor) => {
204+
let data = cursor.data_on(self.dtb);
205+
if data.is_empty() {
206+
visitor.visit_none()
207+
} else {
208+
visitor.visit_some(self)
209+
}
210+
}
211+
ValueCursor::Body(_) => visitor.visit_some(self),
150212
}
151213
}
152214

@@ -176,33 +238,39 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
176238
where
177239
V: de::Visitor<'de>,
178240
{
179-
match name {
180-
"StrSeq" => {
181-
let inner = super::str_seq::Inner {
182-
dtb: self.dtb,
183-
cursor: self.cursor,
184-
};
185-
visitor.visit_borrowed_bytes(unsafe {
186-
core::slice::from_raw_parts(
187-
&inner as *const _ as *const u8,
188-
core::mem::size_of_val(&inner),
189-
)
190-
})
191-
}
192-
"Reg" => {
193-
let inner = super::reg::Inner {
194-
dtb: self.dtb,
195-
reg: self.reg,
196-
cursor: self.cursor,
197-
};
198-
visitor.visit_borrowed_bytes(unsafe {
199-
core::slice::from_raw_parts(
200-
&inner as *const _ as *const u8,
201-
core::mem::size_of_val(&inner),
202-
)
203-
})
204-
}
205-
_ => visitor.visit_newtype_struct(self),
241+
if name == super::VALUE_DESERIALIZER_NAME {
242+
return visitor.visit_newtype_struct(self);
243+
}
244+
match self.cursor {
245+
ValueCursor::Prop(cursor) => match name {
246+
"StrSeq" => {
247+
let inner = super::str_seq::Inner {
248+
dtb: self.dtb,
249+
cursor,
250+
};
251+
visitor.visit_borrowed_bytes(unsafe {
252+
core::slice::from_raw_parts(
253+
&inner as *const _ as *const u8,
254+
core::mem::size_of_val(&inner),
255+
)
256+
})
257+
}
258+
"Reg" => {
259+
let inner = super::reg::Inner {
260+
dtb: self.dtb,
261+
reg: self.reg,
262+
cursor,
263+
};
264+
visitor.visit_borrowed_bytes(unsafe {
265+
core::slice::from_raw_parts(
266+
&inner as *const _ as *const u8,
267+
core::mem::size_of_val(&inner),
268+
)
269+
})
270+
}
271+
_ => visitor.visit_newtype_struct(self),
272+
},
273+
ValueCursor::Body(_) => visitor.visit_newtype_struct(self),
206274
}
207275
}
208276

@@ -232,23 +300,39 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
232300
unreachable!("tuple_struct")
233301
}
234302

235-
fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
303+
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
236304
where
237305
V: de::Visitor<'de>,
238306
{
239-
unreachable!("map")
307+
use super::{StructAccess, Temp};
308+
if let ValueCursor::Body(cursor) = self.cursor {
309+
return visitor.visit_map(StructAccess {
310+
fields: None,
311+
temp: Temp::Node(self.body_cursor, cursor),
312+
de: self,
313+
});
314+
};
315+
unreachable!("Prop -> map")
240316
}
241317

242318
fn deserialize_struct<V>(
243319
self,
244320
_name: &'static str,
245-
_fields: &'static [&'static str],
246-
_visitor: V,
321+
fields: &'static [&'static str],
322+
visitor: V,
247323
) -> Result<V::Value, Self::Error>
248324
where
249325
V: de::Visitor<'de>,
250326
{
251-
unreachable!("struct {_name} {_fields:?}")
327+
use super::{StructAccess, Temp};
328+
if let ValueCursor::Body(cursor) = self.cursor {
329+
return visitor.visit_map(StructAccess {
330+
fields: Some(fields),
331+
temp: Temp::Node(self.body_cursor, cursor),
332+
de: self,
333+
});
334+
};
335+
unreachable!("Prop -> struct {_name} {fields:?}")
252336
}
253337

254338
fn deserialize_enum<V>(
@@ -277,3 +361,34 @@ impl<'de> de::Deserializer<'de> for &mut BorrowedValueDeserializer<'de> {
277361
unreachable!("ignored_any")
278362
}
279363
}
364+
365+
impl ValueDeserializer<'_> {
366+
#[inline]
367+
pub fn move_next(&mut self) -> super::Cursor {
368+
if let ValueCursor::Body(ref mut cursor) = self.cursor {
369+
return cursor.move_on(self.dtb);
370+
};
371+
unreachable!("move_on prop cursor");
372+
}
373+
#[inline]
374+
pub fn step_n(&mut self, n: usize) {
375+
if let ValueCursor::Body(ref mut cursor) = self.cursor {
376+
return cursor.step_n(n);
377+
};
378+
unreachable!("step_n prop cursor");
379+
}
380+
#[inline]
381+
pub fn is_complete_on(&self) -> bool {
382+
if let ValueCursor::Body(cursor) = self.cursor {
383+
return cursor.is_complete_on(self.dtb);
384+
};
385+
unreachable!("is_complete_on prop cursor");
386+
}
387+
#[inline]
388+
pub fn file_index_on(&self) -> usize {
389+
if let ValueCursor::Body(cursor) = self.cursor {
390+
return cursor.file_index_on(self.dtb);
391+
};
392+
unreachable!("file_index_on prop cursor");
393+
}
394+
}

0 commit comments

Comments
 (0)