From aa31418961726ca696cdb9eabd6cd78567f6fd22 Mon Sep 17 00:00:00 2001
From: Jonas Platte <jplatte+git@posteo.de>
Date: Mon, 17 May 2021 16:50:11 +0200
Subject: [PATCH] events: Implement (de)serialization manually for dummy event
 content

The derived implementations use `null` as the serialized form of unit structs.
---
 crates/ruma-events/src/dummy.rs | 45 +++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/crates/ruma-events/src/dummy.rs b/crates/ruma-events/src/dummy.rs
index 27040e29..22017000 100644
--- a/crates/ruma-events/src/dummy.rs
+++ b/crates/ruma-events/src/dummy.rs
@@ -1,7 +1,12 @@
 //! Types for the *m.dummy* event.
 
+use std::fmt;
+
 use ruma_events_macros::EventContent;
-use serde::{Deserialize, Serialize};
+use serde::{
+    de::{self, Deserialize, Deserializer},
+    ser::{Serialize, SerializeStruct as _, Serializer},
+};
 
 /// The payload for `DummyEvent`.
 ///
@@ -14,6 +19,42 @@ use serde::{Deserialize, Serialize};
 /// this *m.dummy* event as the most recent event and using the keyshare request to set up the
 /// session. The keyshare request and *m.dummy* combination should result in the original sending
 /// client receiving keys over the newly established session.
-#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
+#[derive(Clone, Debug, EventContent)]
 #[ruma_event(type = "m.dummy", kind = ToDevice)]
 pub struct DummyToDeviceEventContent;
+
+impl<'de> Deserialize<'de> for DummyToDeviceEventContent {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Visitor;
+
+        impl<'de> de::Visitor<'de> for Visitor {
+            type Value = DummyToDeviceEventContent;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a struct")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::MapAccess<'de>,
+            {
+                while let Some(_) = map.next_entry::<de::IgnoredAny, de::IgnoredAny>()? {}
+                Ok(DummyToDeviceEventContent)
+            }
+        }
+
+        deserializer.deserialize_struct("DummyToDeviceEventContent", &[], Visitor)
+    }
+}
+
+impl Serialize for DummyToDeviceEventContent {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_struct("DummyToDeviceEventContent", 0)?.end()
+    }
+}