From 848509161448f349546330721542cf4ac7e0700f Mon Sep 17 00:00:00 2001
From: Luna Yao <40349250+ZnqbuZ@users.noreply.github.com>
Date: Wed, 13 May 2026 23:14:09 +0200
Subject: [PATCH] add RepeatedSerialize & RepeatedDeserialize

---
 easytier/src/dns/utils/addr.rs |  8 ++--
 easytier/src/proto/utils.rs    | 87 ++++++++++++++++++++++++----------
 2 files changed, 68 insertions(+), 27 deletions(-)

diff --git a/easytier/src/dns/utils/addr.rs b/easytier/src/dns/utils/addr.rs
index 70aeb565..0a94b305 100644
--- a/easytier/src/dns/utils/addr.rs
+++ b/easytier/src/dns/utils/addr.rs
@@ -1,5 +1,5 @@
 use crate::proto;
-use crate::proto::utils::RepeatedMessageModel;
+use crate::proto::utils::{RepeatedDeserialize, RepeatedMessageModel, RepeatedSerialize};
 use anyhow::{Error, anyhow};
 use hickory_net::xfer::Protocol;
 use hickory_resolver::config::{ConnectionConfig, NameServerConfig, ProtocolConfig};
@@ -149,8 +149,10 @@ impl From<u16> for NameServerAddrGroup {
     }
 }
 
-impl<'de> Deserialize<'de> for NameServerAddrGroup {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+impl RepeatedSerialize for NameServerAddr {}
+
+impl<'de> RepeatedDeserialize<'de> for NameServerAddr {
+    fn deserialize<D>(deserializer: D) -> Result<NameServerAddrGroup, D::Error>
     where
         D: Deserializer<'de>,
     {
diff --git a/easytier/src/proto/utils.rs b/easytier/src/proto/utils.rs
index 951a9b2c..39fafac4 100644
--- a/easytier/src/proto/utils.rs
+++ b/easytier/src/proto/utils.rs
@@ -2,7 +2,7 @@ use delegate::delegate;
 use derivative::Derivative;
 use derive_more::{AsMut, AsRef, Deref, DerefMut, From, IntoIterator};
 use prost::Message;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use sha2::{Digest, Sha256};
 
 /// Generates a stable digest strictly within the lifecycle of the current process.
@@ -36,43 +36,27 @@ where
 }
 
 #[derive(
-    Derivative,
-    Debug,
-    Clone,
-    PartialEq,
-    Eq,
-    Hash,
-    From,
-    Deref,
-    DerefMut,
-    AsRef,
-    AsMut,
-    Serialize,
-    Deserialize,
-    IntoIterator,
+    Derivative, Debug, Clone, PartialEq, Eq, Hash, From, Deref, DerefMut, AsRef, AsMut, IntoIterator,
 )]
 #[derivative(Default(bound = ""))]
 #[as_ref(forward)]
 #[as_mut(forward)]
-#[serde(transparent)]
 #[into_iterator(owned, ref, ref_mut)]
-pub struct RepeatedMessageModel<Model>(Vec<Model>);
-
-impl<Model> RepeatedMessageModel<Model> {
-    pub fn into_inner(self) -> Vec<Model> {
-        self.0
-    }
+pub struct RepeatedMessageModel<Model> {
+    pub models: Vec<Model>,
 }
 
 impl<Model> FromIterator<Model> for RepeatedMessageModel<Model> {
     fn from_iter<I: IntoIterator<Item = Model>>(iter: I) -> Self {
-        Self(iter.into_iter().collect())
+        Self {
+            models: iter.into_iter().collect(),
+        }
     }
 }
 
 impl<Model> Extend<Model> for RepeatedMessageModel<Model> {
     delegate! {
-        to self.0 {
+        to self.models {
             fn extend<T: IntoIterator<Item = Model>>(&mut self, iter: T);
         }
     }
@@ -99,3 +83,58 @@ where
         value.into_iter().map(Into::into).collect()
     }
 }
+
+pub trait RepeatedSerialize: Serialize + Sized {
+    fn serialize<S>(models: &RepeatedMessageModel<Self>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        Serialize::serialize(&**models, serializer)
+    }
+}
+
+pub trait RepeatedDeserialize<'de>: Deserialize<'de> {
+    fn deserialize<D>(deserializer: D) -> Result<RepeatedMessageModel<Self>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Vec::deserialize(deserializer).map(Into::into)
+    }
+
+    #[doc(hidden)]
+    fn deserialize_in_place<D>(
+        deserializer: D,
+        place: &mut RepeatedMessageModel<Self>,
+    ) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Deserialize::deserialize_in_place(deserializer, &mut place.models)
+    }
+}
+
+impl<Model: RepeatedSerialize> Serialize for RepeatedMessageModel<Model> {
+    delegate! {
+        #[through(RepeatedSerialize)]
+        to self {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: Serializer;
+        }
+    }
+}
+
+impl<'de, Model: RepeatedDeserialize<'de>> Deserialize<'de> for RepeatedMessageModel<Model> {
+    delegate! {
+        to RepeatedDeserialize {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: Deserializer<'de>;
+
+            #[doc(hidden)]
+            fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
+            where
+                D: Deserializer<'de>;
+        }
+    }
+}