xml: Remove generics from XmlSerialize

crates/caldav/src/error.rs

@@ -17,7 +17,7 @@ pub enum Precondition {
 impl IntoResponse for Precondition {
     fn into_response(self) -> axum::response::Response {
         let mut output: Vec<_> = b"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n".into();
-        let mut writer = quick_xml::Writer::new_with_indent(&mut output, b' ', 4);
+        let mut writer = quick_xml::Writer::new_with_indent(output.as_mut_slice(), b' ', 4);
 
         let error = rustical_dav::xml::ErrorElement(&self);
         if let Err(err) = error.serialize_root(&mut writer) {

crates/dav/src/privileges.rs

@@ -16,12 +16,12 @@ pub enum UserPrivilege {
 }
 
 impl XmlSerialize for UserPrivilegeSet {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         #[derive(XmlSerialize)]
         pub struct FakeUserPrivilegeSet {

crates/dav/src/xml/multistatus.rs

@@ -19,12 +19,12 @@ pub struct PropstatElement<PropType: XmlSerialize> {
     pub status: StatusCode,
 }
 
-fn xml_serialize_status<W: ::std::io::Write>(
+fn xml_serialize_status(
     status: &StatusCode,
     ns: Option<Namespace>,
     tag: Option<&[u8]>,
     namespaces: &HashMap<Namespace, &[u8]>,
-    writer: &mut quick_xml::Writer<W>,
+    writer: &mut quick_xml::Writer<&mut [u8]>,
 ) -> std::io::Result<()> {
     XmlSerialize::serialize(&format!("HTTP/1.1 {}", status), ns, tag, namespaces, writer)
 }
@@ -49,12 +49,12 @@ pub struct ResponseElement<PropstatType: XmlSerialize> {
     pub propstat: Vec<PropstatWrapper<PropstatType>>,
 }
 
-fn xml_serialize_optional_status<W: ::std::io::Write>(
+fn xml_serialize_optional_status(
     val: &Option<StatusCode>,
     ns: Option<Namespace>,
     tag: Option<&[u8]>,
     namespaces: &HashMap<Namespace, &[u8]>,
-    writer: &mut quick_xml::Writer<W>,
+    writer: &mut quick_xml::Writer<&mut [u8]>,
 ) -> std::io::Result<()> {
     XmlSerialize::serialize(
         &val.map(|status| format!("HTTP/1.1 {}", status)),

crates/dav/src/xml/tag_list.rs

@@ -10,12 +10,12 @@ use std::collections::HashMap;
 pub struct TagList(Vec<(Option<NamespaceOwned>, String)>);
 
 impl XmlSerialize for TagList {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         let prefix = ns
             .map(|ns| namespaces.get(&ns))

crates/xml/derive/src/xml_enum/impl_se.rs

@@ -13,12 +13,12 @@ impl Enum {
 
         quote! {
             impl #impl_generics ::rustical_xml::XmlSerialize for #ident #type_generics #where_clause {
-                fn serialize<W: ::std::io::Write>(
+                fn serialize(
                     &self,
                     ns: Option<::quick_xml::name::Namespace>,
                     tag: Option<&[u8]>,
                     namespaces: &::std::collections::HashMap<::quick_xml::name::Namespace, &[u8]>,
-                    writer: &mut ::quick_xml::Writer<W>
+                    writer: &mut ::quick_xml::Writer<&mut [u8]>
                 ) -> ::std::io::Result<()> {
                     use ::quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
 

crates/xml/derive/src/xml_struct/impl_se.rs

@@ -88,12 +88,12 @@ impl NamedStruct {
 
         quote! {
             impl #impl_generics ::rustical_xml::XmlSerialize for #ident #type_generics #where_clause {
-                fn serialize<W: ::std::io::Write>(
+                fn serialize(
                     &self,
                     ns: Option<::quick_xml::name::Namespace>,
                     tag: Option<&[u8]>,
                     namespaces: &::std::collections::HashMap<::quick_xml::name::Namespace, &[u8]>,
-                    writer: &mut ::quick_xml::Writer<W>
+                    writer: &mut ::quick_xml::Writer<&mut [u8]>
                 ) -> ::std::io::Result<()> {
                     use ::quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
 

crates/xml/src/se.rs

@@ -7,24 +7,24 @@ use std::collections::HashMap;
 pub use xml_derive::XmlSerialize;
 
 pub trait XmlSerialize {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()>;
 
     fn attributes<'a>(&self) -> Option<Vec<Attribute<'a>>>;
 }
 
 impl<T: XmlSerialize> XmlSerialize for Option<T> {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         if let Some(some) = self {
             some.serialize(ns, tag, namespaces, writer)
@@ -39,36 +39,30 @@ impl<T: XmlSerialize> XmlSerialize for Option<T> {
 }
 
 pub trait XmlSerializeRoot {
-    fn serialize_root<W: std::io::Write>(
+    fn serialize_root(&self, writer: &mut quick_xml::Writer<&mut [u8]>) -> std::io::Result<()>;
-        &self,
-        writer: &mut quick_xml::Writer<W>,
-    ) -> std::io::Result<()>;
 
     fn serialize_to_string(&self) -> std::io::Result<String> {
         let mut buf: Vec<_> = b"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n".into();
-        let mut writer = quick_xml::Writer::new(&mut buf);
+        let mut writer = quick_xml::Writer::new(buf.as_mut_slice());
         self.serialize_root(&mut writer)?;
         Ok(String::from_utf8_lossy(&buf).to_string())
     }
 }
 
 impl<T: XmlSerialize + XmlRootTag> XmlSerializeRoot for T {
-    fn serialize_root<W: std::io::Write>(
+    fn serialize_root(&self, writer: &mut quick_xml::Writer<&mut [u8]>) -> std::io::Result<()> {
-        &self,
-        writer: &mut quick_xml::Writer<W>,
-    ) -> std::io::Result<()> {
         let namespaces = Self::root_ns_prefixes();
         self.serialize(Self::root_ns(), Some(Self::root_tag()), &namespaces, writer)
     }
 }
 
 impl XmlSerialize for () {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         let prefix = ns
             .map(|ns| namespaces.get(&ns))

crates/xml/src/value.rs

@@ -104,12 +104,12 @@ impl<T: ValueDeserialize> XmlDeserialize for T {
 }
 
 impl<T: ValueSerialize> XmlSerialize for T {
-    fn serialize<W: std::io::Write>(
+    fn serialize(
         &self,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut quick_xml::Writer<W>,
+        writer: &mut quick_xml::Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         let prefix = ns
             .map(|ns| namespaces.get(&ns))

crates/xml/tests/se_struct.rs

@@ -124,12 +124,12 @@ fn test_struct_serialize_with() {
         href: String,
     }
 
-    fn serialize_href<W: ::std::io::Write>(
+    fn serialize_href(
         val: &str,
         ns: Option<Namespace>,
         tag: Option<&[u8]>,
         namespaces: &HashMap<Namespace, &[u8]>,
-        writer: &mut Writer<W>,
+        writer: &mut Writer<&mut [u8]>,
     ) -> std::io::Result<()> {
         val.to_uppercase().serialize(ns, tag, namespaces, writer)
     }