From 519718d9b55c7b424b4e3af604ddd7dc86527c1e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonas=20Sch=C3=A4fer?= <jonas@zombofant.net>
Date: Mon, 2 Sep 2024 17:26:13 +0200
Subject: [PATCH] xmlstream: add support for boxing the transport

This is useful in situations where we don't want to care about the
specific type of the underlying transport.
---
 tokio-xmpp/src/xmlstream/common.rs | 27 +++++++++++++++++++++++++++
 tokio-xmpp/src/xmlstream/mod.rs    | 17 +++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/tokio-xmpp/src/xmlstream/common.rs b/tokio-xmpp/src/xmlstream/common.rs
index f4d4c0a8da0d6cd5df7c8754b4ec599f40a6e9e8..ca82c419ec8faa9fa5b2794d1f64f2d396f50188 100644
--- a/tokio-xmpp/src/xmlstream/common.rs
+++ b/tokio-xmpp/src/xmlstream/common.rs
@@ -25,6 +25,8 @@ use xso::{
     AsXml, FromEventsBuilder, FromXml, Item,
 };
 
+use crate::connect::AsyncReadAndWrite;
+
 use super::capture::{log_enabled, log_recv, log_send, CaptureBufRead};
 
 use xmpp_parsers::ns::STREAM as XML_STREAM_NS;
@@ -272,6 +274,31 @@ impl<Io: AsyncBufRead + AsyncWrite> RawXmlStream<Io> {
     pub(super) fn into_inner(self) -> Io {
         self.parser.into_inner().0.into_inner()
     }
+
+    /// Box the underlying transport stream.
+    ///
+    /// This removes the specific type of the transport from the XML stream's
+    /// type signature.
+    pub(super) fn box_stream(self) -> RawXmlStream<Box<dyn AsyncReadAndWrite + Send + 'static>>
+    where
+        Io: AsyncReadAndWrite + Send + 'static,
+    {
+        let (io, p) = self.parser.into_inner();
+        let mut io = CaptureBufRead::wrap(Box::new(io) as Box<_>);
+        if log_enabled() {
+            io.enable_capture();
+        }
+        let parser = rxml::AsyncReader::wrap(io, p);
+        RawXmlStream {
+            parser,
+            timeouts: self.timeouts,
+            writer: self.writer,
+            tx_buffer: self.tx_buffer,
+            tx_buffer_logged: self.tx_buffer_logged,
+            tx_buffer_high_water_mark: self.tx_buffer_high_water_mark,
+            stream_ns: self.stream_ns,
+        }
+    }
 }
 
 impl<Io: AsyncWrite> RawXmlStream<Io> {
diff --git a/tokio-xmpp/src/xmlstream/mod.rs b/tokio-xmpp/src/xmlstream/mod.rs
index 739282e564dc031210612f071d8216aeeeca110b..1ad1ef623abc74537f6ae61b2187bb7fded06e8e 100644
--- a/tokio-xmpp/src/xmlstream/mod.rs
+++ b/tokio-xmpp/src/xmlstream/mod.rs
@@ -70,6 +70,8 @@ use tokio::io::{AsyncBufRead, AsyncWrite};
 
 use xso::{AsXml, FromXml, Item};
 
+use crate::connect::AsyncReadAndWrite;
+
 mod capture;
 mod common;
 mod initiator;
@@ -337,6 +339,21 @@ impl<Io: AsyncBufRead + AsyncWrite + Unpin, T: FromXml + AsXml + fmt::Debug> Xml
         self.assert_retypable();
         self.inner.into_inner()
     }
+
+    /// Box the underlying transport stream.
+    ///
+    /// This removes the specific type of the transport from the XML stream's
+    /// type signature.
+    pub fn box_stream(self) -> XmlStream<Box<dyn AsyncReadAndWrite + Send + 'static>, T>
+    where
+        Io: AsyncReadAndWrite + Send + 'static,
+    {
+        XmlStream {
+            inner: self.inner.box_stream(),
+            read_state: self.read_state,
+            write_state: self.write_state,
+        }
+    }
 }
 
 impl<Io: AsyncBufRead, T: FromXml + AsXml + fmt::Debug> Stream for XmlStream<Io, T> {