recursive serialization

1 files changed, 32 insertions, 22 deletions

diff --git a/msg_socket2/tests/round_trip.rs b/msg_socket2/tests/round_trip.rs
index efec94b..1bb6636 100644
--- a/msg_socket2/tests/round_trip.rs
+++ b/msg_socket2/tests/round_trip.rs
@@ -3,14 +3,33 @@ use std::os::unix::prelude::*;
 use std::fmt::{self, Formatter};
 use std::marker::PhantomData;
 
-use msg_socket2::*;
-use serde::de::*;
-use serde::ser::*;
+use msg_socket2::{
+    ser::{
+        SerializeAdapter, SerializeRawFd, SerializeStruct, SerializeStructFds,
+        SerializeTupleStruct, SerializeTupleStructFds,
+    },
+    DeserializeWithFds, DeserializerWithFds, FdSerializer, SerializeWithFds, Serializer, Socket,
+};
+use serde::de::{Deserializer, SeqAccess};
 use sys_util::net::UnixSeqpacket;
 
 #[derive(Debug)]
 struct Inner(RawFd, u16);
 
+impl SerializeWithFds for Inner {
+    fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
+        let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
+        state.serialize_field(&self.1)?;
+        state.end()
+    }
+
+    fn serialize_fds<Ser: FdSerializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
+        let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
+        state.serialize_field(&SerializeRawFd::new(&self.0))?;
+        state.end()
+    }
+}
+
 #[derive(Debug)]
 struct Test {
     fd: RawFd,
@@ -18,26 +37,17 @@ struct Test {
 }
 
 impl SerializeWithFds for Test {
-    fn serialize<Ser: SerializerWithFds>(
-        &self,
-        mut serializer: Ser,
-    ) -> Result<<Ser::Ser as Serializer>::Ok, <Ser::Ser as Serializer>::Error> {
-        serializer.fds().push(self.fd);
-        serializer.fds().push(self.inner.0);
-
-        struct SerializableInner<'a>(&'a Inner);
-
-        impl<'a> Serialize for SerializableInner<'a> {
-            fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-                let mut state = serializer.serialize_tuple_struct("Inner", 1)?;
-                state.serialize_field(&(self.0).1)?;
-                state.end()
-            }
-        }
-
-        let mut state = serializer.serializer().serialize_struct("Test", 1)?;
+    fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
+        let mut state = serializer.serialize_struct("Test", 1)?;
         state.skip_field("fd")?;
-        state.serialize_field("inner", &SerializableInner(&self.inner))?;
+        state.serialize_field("inner", &SerializeAdapter::new(&self.inner))?;
+        state.end()
+    }
+
+    fn serialize_fds<Ser: FdSerializer>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error> {
+        let mut state = serializer.serialize_struct("Test", 2)?;
+        state.serialize_field("fd", &SerializeRawFd::new(&self.fd))?;
+        state.serialize_field("inner", &self.inner)?;
         state.end()
     }
 }