feat: add optional deserializer generics static bounds

2 files changed, 46 insertions, 23 deletions

diff --git a/src/deserializer/buffered.rs b/src/deserializer/buffered.rs
index 7a6058b..6568910 100644
--- a/src/deserializer/buffered.rs
+++ b/src/deserializer/buffered.rs
@@ -5,25 +5,29 @@ use std::io::BufRead;
 use quick_xml::events::Event;
 use quick_xml::Reader;
 
-use crate::deserializer::{Deserializer, Error, IgnoreEnd};
+use crate::deserializer::{Deserializer, Error, IgnoreEnd, MaybeStatic};
 use crate::event::EventExt;
 use crate::tagged::TagStart;
+use crate::util::trait_alias;
 use crate::DeserializeTagged;
 
+trait_alias! {
+    /// A XML deserializer source with an internal buffer.
+    pub Source: BufRead + MaybeStatic;
+}
+
 /// XML deserializer using a source which has an internal buffer.
-pub struct Buffered<Source: BufRead>
+pub struct Buffered<TSource: Source>
 {
-    reader: Reader<Source>,
+    reader: Reader<TSource>,
     leftover_event: Option<Event<'static>>,
     buf: Vec<u8>,
 }
 
-impl<Source> Buffered<Source>
-where
-    Source: BufRead,
+impl<TSource: Source> Buffered<TSource>
 {
     /// Returns a new [`Buffered`].
-    pub fn new(source: Source) -> Self
+    pub fn new(source: TSource) -> Self
     {
         let mut reader = Reader::from_reader(source);
 
@@ -38,9 +42,7 @@ where
     }
 }
 
-impl<Source> Deserializer for Buffered<Source>
-where
-    Source: BufRead,
+impl<TSource: Source> Deserializer for Buffered<TSource>
 {
     fn de_tag<De: DeserializeTagged>(
         &mut self,
@@ -84,9 +86,9 @@ where
         Ok(deserialized)
     }
 
-    fn de_tag_list<De: DeserializeTagged>(
+    fn de_tag_list<De: DeserializeTagged, Name: AsRef<str>>(
         &mut self,
-        tag_name: Option<&str>,
+        tag_name: Option<Name>,
     ) -> Result<Vec<De>, Error<De::Error>>
     {
         let mut deserialized_items = Vec::new();
@@ -94,10 +96,10 @@ where
         loop {
             let start = match self.read_event()? {
                 Event::Start(start)
-                    if tag_name.map_or_else(
+                    if tag_name.as_ref().map_or_else(
                         || true,
                         |expected_tag_name| {
-                            start.name().as_ref() == expected_tag_name.as_bytes()
+                            start.name().as_ref() == expected_tag_name.as_ref().as_bytes()
                         },
                     ) =>
                 {
@@ -174,9 +176,7 @@ where
     }
 }
 
-impl<Source> Buffered<Source>
-where
-    Source: BufRead,
+impl<TSource: Source> Buffered<TSource>
 {
     fn read_end_event(&mut self, tag_name: &[u8]) -> Result<(), Error<Infallible>>
     {
diff --git a/src/deserializer/mod.rs b/src/deserializer/mod.rs
index bd0c0e4..e0c5f6d 100644
--- a/src/deserializer/mod.rs
+++ b/src/deserializer/mod.rs
@@ -2,6 +2,7 @@
 use std::convert::Infallible;
 
 use crate::tagged::TagStart;
+use crate::util::trait_alias;
 use crate::DeserializeTagged;
 
 pub mod buffered;
@@ -23,24 +24,28 @@ pub trait Deserializer
     ///
     /// # Errors
     /// Returns `Err` if deserialization fails.
-    fn de_tag_with<Output, Err, DeserializeFn>(
+    fn de_tag_with<Output, Err, Func>(
         &mut self,
         tag_name: &str,
         ignore_end: IgnoreEnd,
-        deserialize: DeserializeFn,
+        deserialize: Func,
     ) -> Result<Output, Error<Err>>
     where
+        Output: MaybeStatic,
         Err: std::error::Error + Send + Sync + 'static,
-        DeserializeFn: FnOnce(&TagStart, &mut Self) -> Result<Output, Err>;
+        Func: FnOnce(&TagStart, &mut Self) -> Result<Output, Err> + MaybeStatic;
 
     /// Deserializes a list of tagged elements.
     ///
     /// # Errors
     /// Returns `Err` if deserialization fails.
-    fn de_tag_list<De: DeserializeTagged>(
+    fn de_tag_list<De, TagName>(
         &mut self,
-        tag_name: Option<&str>,
-    ) -> Result<Vec<De>, Error<De::Error>>;
+        tag_name: Option<TagName>,
+    ) -> Result<Vec<De>, Error<De::Error>>
+    where
+        De: DeserializeTagged,
+        TagName: AsRef<str> + MaybeStatic;
 
     /// Deserializes a text element.
     ///
@@ -63,6 +68,24 @@ pub trait Deserializer
     fn skip_to_tag_end(&mut self, tag_name: &str) -> Result<(), Error<Infallible>>;
 }
 
+macro_rules! maybe_static_doc {
+    () => {
+        "Bound to `'static` if the `deserializer-static-generics` feature is enabled."
+    };
+}
+
+#[cfg(any(not(feature = "deserializer-static-generics"), doc))]
+trait_alias! {
+    #[doc = maybe_static_doc!()]
+    pub MaybeStatic;
+}
+
+#[cfg(all(feature = "deserializer-static-generics", not(doc)))]
+trait_alias! {
+    #[doc = maybe_static_doc!()]
+    pub MaybeStatic: 'static;
+}
+
 /// Whether or not to skip the end tag of a tagged element.
 ///
 /// **Should be `No`**.