refactor: NodeSeq as a wrapper of GroupDeserializer

Signed-off-by: Woshiluo Luo <woshiluo.luo@outlook.com>

Author: woshiluo

src/de_mut/group.rs

@@ -2,6 +2,7 @@
 use serde::de;
 
 #[allow(unused)]
+#[derive(Clone, Copy)]
 pub(super) struct GroupDeserializer<'de> {
     pub dtb: RefDtb<'de>,
     pub cursor: GroupCursor,

src/de_mut/node_seq.rs

@@ -1,5 +1,6 @@
 use super::{BodyCursor, GroupCursor, RefDtb, RegConfig, StructDeserializer};
-use core::{fmt::Debug, marker::PhantomData, mem::MaybeUninit};
+use crate::de_mut::GroupDeserializer;
+use core::{fmt::Debug, marker::PhantomData};
 use serde::{de, Deserialize};
 
 /// 一组名字以 `@...` 区分，同类、同级且连续的节点的映射。
@@ -8,11 +9,7 @@ use serde::{de, Deserialize};
 /// 因此这些节点将延迟解析。
 /// 迭代 `NodeSeq` 可获得一系列 [`NodeSeqItem`]，再调用 `deserialize` 方法分别解析每个节点。
 pub struct NodeSeq<'de> {
-    dtb: RefDtb<'de>,
-    reg: RegConfig,
-    cursor: GroupCursor,
-    len_item: usize,
-    len_name: usize,
+    inner: GroupDeserializer<'de>,
 }
 
 /// 连续节点迭代器。
@@ -52,7 +49,7 @@ impl<'de, 'b> Deserialize<'de> for NodeSeq<'b> {
             {
                 // 结构体转为内存切片，然后拷贝过来
                 if v.len() == core::mem::size_of::<Self::Value>() {
-                    Ok(Self::Value::from_raw_parts(v.as_ptr()))
+                    Ok(Self::Value::from_raw_inner_parts(v.as_ptr()))
                 } else {
                     Err(E::invalid_length(
                         v.len(),
@@ -74,25 +71,21 @@ impl<'de, 'b> Deserialize<'de> for NodeSeq<'b> {
 }
 
 impl<'de> NodeSeq<'de> {
-    fn from_raw_parts(ptr: *const u8) -> Self {
+    fn from_raw_inner_parts(ptr: *const u8) -> Self {
         // 直接从指针拷贝
-        let res = unsafe {
-            let mut res = MaybeUninit::<Self>::uninit();
-            core::ptr::copy_nonoverlapping(
-                ptr,
-                res.as_mut_ptr() as *mut _,
-                core::mem::size_of::<Self>(),
-            );
-            res.assume_init()
-        };
-        // 初始化
-        res.cursor.init_on(res.dtb, res.len_item, res.len_name);
+        let original_inner = unsafe { &*(ptr as *const GroupDeserializer<'_>) };
+        let res = Self {
+            inner: original_inner.clone(),
+        }; // 初始化
+        res.inner
+            .cursor
+            .init_on(res.inner.dtb, res.inner.len_item, res.inner.len_name);
         res
     }
 
     /// 连续节点总数。
     pub const fn len(&self) -> usize {
-        self.len_item
+        self.inner.len_item
     }
 
     /// 如果连续节点数量为零，返回 true。但连续节点数量不可能为零。
@@ -104,7 +97,7 @@ impl<'de> NodeSeq<'de> {
     pub const fn iter<'b>(&'b self) -> NodeSeqIter<'de, 'b> {
         NodeSeqIter {
             seq: self,
-            cursor: self.cursor,
+            cursor: self.inner.cursor,
             i: 0,
         }
     }
@@ -127,26 +120,29 @@ impl Debug for NodeSeq<'_> {
 
 impl Drop for NodeSeq<'_> {
     fn drop(&mut self) {
-        self.cursor.drop_on(self.dtb, self.len_item);
+        self.inner
+            .cursor
+            .drop_on(self.inner.dtb, self.inner.len_item);
     }
 }
 
 impl<'de, 'b> Iterator for NodeSeqIter<'de, 'b> {
     type Item = NodeSeqItem<'de>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if self.i >= self.seq.len_item {
+        if self.i >= self.seq.inner.len_item {
             None
         } else {
             self.i += 1;
-            let (name, body) = self.cursor.name_on(self.seq.dtb);
-            let off_next = self.cursor.offset_on(self.seq.dtb);
+            let dtb = self.seq.inner.dtb;
+            let (name, body) = self.cursor.name_on(dtb);
+            let off_next = self.cursor.offset_on(dtb);
             self.cursor.step_n(off_next);
             Some(Self::Item {
-                dtb: self.seq.dtb,
-                reg: self.seq.reg,
+                dtb,
+                reg: self.seq.inner.reg,
                 body,
-                at: unsafe { core::str::from_utf8_unchecked(&name[self.seq.len_name + 1..]) },
+                at: unsafe { core::str::from_utf8_unchecked(&name[self.seq.inner.len_name + 1..]) },
             })
         }
     }