send wl::Params over socket

3 files changed, 83 insertions, 3 deletions

diff --git a/msg_socket2/src/de.rs b/msg_socket2/src/de.rs
index fa6582a..67073c0 100644
--- a/msg_socket2/src/de.rs
+++ b/msg_socket2/src/de.rs
@@ -17,7 +17,7 @@ use std::fmt::{self, Formatter};
 use std::marker::PhantomData;
 
 pub use serde::de::{
-    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, SeqAccess, StdError,
+    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, StdError,
     VariantAccess, Visitor,
 };
 
@@ -352,7 +352,7 @@ pub trait MapAccessWithFds<'de>: Sized {
 
     /// Like `MapAccess::next_value_seed`, but `seed` is a
     /// `DeserializeWithFdsSeed` instead of a `DeserializeSeed`.
-    fn next_value_seed<V>(&mut self, seed: V) -> Result<Option<V::Value>, Self::Error>
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
     where
         V: DeserializeWithFdsSeed<'de>;
 
@@ -362,7 +362,15 @@ pub trait MapAccessWithFds<'de>: Sized {
         &mut self,
         kseed: K,
         vseed: V,
-    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>;
+    ) -> Result<Option<(K::Value, V::Value)>, Self::Error> {
+        match self.next_key_seed(kseed)? {
+            Some(key) => {
+                let value = self.next_value_seed(vseed)?;
+                Ok(Some((key, value)))
+            }
+            None => Ok(None),
+        }
+    }
 
     /// Like `MapAccess::next_key`, but returns a `DeserializeWithFds`
     /// instead of a `Deserialize`.
@@ -400,6 +408,46 @@ pub trait MapAccessWithFds<'de>: Sized {
     fn invite<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error>;
 }
 
+impl<'de, 'fds, A, F> MapAccessWithFds<'de> for WithFds<'fds, A, F>
+where
+    A: MapAccess<'de>,
+    F: Iterator<Item = Fd>,
+{
+    type Error = A::Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
+    where
+        K: DeserializeWithFdsSeed<'de>,
+    {
+        let wrapper = WithFds {
+            inner: seed,
+            fds: self.fds,
+        };
+
+        self.inner.next_key_seed(wrapper)
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
+    where
+        V: DeserializeWithFdsSeed<'de>,
+    {
+        let wrapper = WithFds {
+            inner: seed,
+            fds: self.fds,
+        };
+
+        self.inner.next_value_seed(wrapper)
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        self.inner.size_hint()
+    }
+
+    fn invite<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
+        visitor.visit_map(self.inner)
+    }
+}
+
 /// Like `EnumAccess`, but variants provide access to file descriptors
 /// as well as data.
 pub trait EnumAccessWithFds<'de>: Sized {
@@ -578,6 +626,17 @@ where
         self.inner.expecting(f)
     }
 
+    fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
+        self.inner.visit_none()
+    }
+
+    fn visit_some<D: Deserializer<'de>>(self, deserializer: D) -> Result<Self::Value, D::Error> {
+        self.inner.visit_some(WithFds {
+            inner: deserializer,
+            fds: self.fds,
+        })
+    }
+
     fn visit_seq<A: SeqAccess<'de>>(self, data: A) -> Result<Self::Value, A::Error> {
         self.inner.visit_seq(WithFds {
             inner: data,
@@ -585,6 +644,13 @@ where
         })
     }
 
+    fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
+        self.inner.visit_map(WithFds {
+            inner: map,
+            fds: self.fds,
+        })
+    }
+
     fn visit_enum<A: EnumAccess<'de>>(self, data: A) -> Result<Self::Value, A::Error> {
         self.inner.visit_enum(WithFds {
             inner: data,
diff --git a/msg_socket2/src/ser.rs b/msg_socket2/src/ser.rs
index 1391d12..8be85aa 100644
--- a/msg_socket2/src/ser.rs
+++ b/msg_socket2/src/ser.rs
@@ -555,6 +555,8 @@ macro_rules! fd_impl {
     };
 }
 
+serialize_impl!(());
+
 serialize_impl!(u8);
 serialize_impl!(u16);
 serialize_impl!(u32);
diff --git a/msg_socket2/tests/option.rs b/msg_socket2/tests/option.rs
new file mode 100644
index 0000000..130dd7d
--- /dev/null
+++ b/msg_socket2/tests/option.rs
@@ -0,0 +1,12 @@
+use msg_socket2::Socket;
+use sys_util::net::UnixSeqpacket;
+
+#[test]
+fn option() {
+    let (f1, f2) = UnixSeqpacket::pair().unwrap();
+    let s1: Socket<_, ()> = Socket::new(f1);
+    let s2: Socket<(), Option<String>> = Socket::new(f2);
+
+    s1.send(Some("hello world".to_string())).unwrap();
+    assert_eq!(s2.recv().unwrap(), Some("hello world".to_string()));
+}