Use a macro to generate all implementations for a wrapper type

Author: Nemo157

src/bufread/brotli.rs

@@ -1,19 +1,26 @@
 macro_rules! encoder {
-    ($(#[$attr:meta])* $name:ident) => {
+    ($(#[$attr:meta])* $name:ident<$inner:ident> $({ $($constructor:tt)* })*) => {
         $(#[$attr])*
         #[pin_project::pin_project]
         #[derive(Debug)]
         ///
         /// This structure implements an [`AsyncRead`](futures_io::AsyncRead) interface and will
         /// read uncompressed data from an underlying stream and emit a stream of compressed data.
-        pub struct $name<R: futures_io::AsyncBufRead> {
+        pub struct $name<$inner: futures_io::AsyncBufRead> {
             #[pin]
-            inner: crate::bufread::Encoder<R, crate::codec::$name>,
+            inner: crate::bufread::Encoder<$inner, crate::codec::$name>,
         }
 
-        impl<R: futures_io::AsyncBufRead> $name<R> {
+        impl<$inner: futures_io::AsyncBufRead> $name<$inner> {
+            $(
+                /// Creates a new encoder which will read uncompressed data from the given stream
+                /// and emit a compressed stream.
+                ///
+                $($constructor)*
+            )*
+
             /// Acquires a reference to the underlying reader that this encoder is wrapping.
-            pub fn get_ref(&self) -> &R {
+            pub fn get_ref(&self) -> &$inner {
                 self.inner.get_ref()
             }
 
@@ -22,7 +29,7 @@ macro_rules! encoder {
             ///
             /// Note that care must be taken to avoid tampering with the state of the reader which
             /// may otherwise confuse this encoder.
-            pub fn get_mut(&mut self) -> &mut R {
+            pub fn get_mut(&mut self) -> &mut $inner {
                 self.inner.get_mut()
             }
 
@@ -31,20 +38,20 @@ macro_rules! encoder {
             ///
             /// Note that care must be taken to avoid tampering with the state of the reader which
             /// may otherwise confuse this encoder.
-            pub fn get_pin_mut(self: std::pin::Pin<&mut Self>) -> std::pin::Pin<&mut R> {
+            pub fn get_pin_mut(self: std::pin::Pin<&mut Self>) -> std::pin::Pin<&mut $inner> {
                 self.project().inner.get_pin_mut()
             }
 
             /// Consumes this encoder returning the underlying reader.
             ///
             /// Note that this may discard internal state of this encoder, so care should be taken
             /// to avoid losing resources when this is called.
-            pub fn into_inner(self) -> R {
+            pub fn into_inner(self) -> $inner {
                 self.inner.into_inner()
             }
         }
 
-        impl<R: futures_io::AsyncBufRead> futures_io::AsyncRead for $name<R> {
+        impl<$inner: futures_io::AsyncBufRead> futures_io::AsyncRead for $name<$inner> {
             fn poll_read(
                 self: std::pin::Pin<&mut Self>,
                 cx: &mut std::task::Context<'_>,

src/bufread/bzip.rs

@@ -1,34 +1,10 @@
 //! Types which operate over [`AsyncBufRead`](futures_io::AsyncBufRead) streams, both encoders and
 //! decoders for various formats.
 
-mod generic;
 #[macro_use]
 mod macros;
-
-#[cfg(feature = "brotli")]
-mod brotli;
-#[cfg(feature = "bzip")]
-mod bzip;
-#[cfg(feature = "deflate")]
-mod deflate;
-#[cfg(feature = "gzip")]
-mod gzip;
-#[cfg(feature = "zlib")]
-mod zlib;
-#[cfg(feature = "zstd")]
-mod zstd;
+mod generic;
 
 pub(crate) use generic::{Decoder, Encoder};
 
-#[cfg(feature = "brotli")]
-pub use self::brotli::{BrotliDecoder, BrotliEncoder};
-#[cfg(feature = "bzip")]
-pub use self::bzip::{BzDecoder, BzEncoder};
-#[cfg(feature = "deflate")]
-pub use self::deflate::{DeflateDecoder, DeflateEncoder};
-#[cfg(feature = "gzip")]
-pub use self::gzip::{GzipDecoder, GzipEncoder};
-#[cfg(feature = "zlib")]
-pub use self::zlib::{ZlibDecoder, ZlibEncoder};
-#[cfg(feature = "zstd")]
-pub use self::zstd::{ZstdDecoder, ZstdEncoder};
+algos!(bufread<R>);

src/bufread/deflate.rs

@@ -75,6 +75,8 @@
     missing_debug_implementations
 )]
 
+#[macro_use]
+mod macros;
 mod codec;
 
 #[cfg(feature = "bufread")]

src/bufread/gzip.rs

@@ -0,0 +1,97 @@
+macro_rules! algos {
+    (@algo $algo:ident [$algo_s:expr] $decoder:ident $encoder:ident<$inner:ident> $({ $($constructor:tt)* })*) => {
+        #[cfg(feature = $algo_s)]
+        decoder! {
+            /// A
+            #[doc = $algo_s]
+            /// decoder, or decompressor.
+            #[cfg_attr(docsrs, doc(cfg(feature = $algo_s)))]
+            $decoder
+        }
+
+        #[cfg(feature = $algo_s)]
+        encoder! {
+            /// A
+            #[doc = $algo_s]
+            /// encoder, or compressor.
+            #[cfg_attr(docsrs, doc(cfg(feature = $algo_s)))]
+            $encoder<$inner> $({ $($constructor)* })*
+        }
+    };
+
+    ($mod:ident<$inner:ident>) => {
+        algos!(@algo brotli ["brotli"] BrotliDecoder BrotliEncoder<$inner> {
+            /// The `level` argument here is typically 0-11.
+            pub fn new(reader: $inner, level: u32) -> Self {
+                let mut params = brotli2::CompressParams::new();
+                params.quality(level);
+                Self::from_params(reader, &params)
+            }
+        } {
+            pub fn from_params(inner: $inner, params: &brotli2::CompressParams) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::BrotliEncoder::new(params),
+                    ),
+                }
+            }
+        });
+
+        algos!(@algo bzip ["bzip"] BzDecoder BzEncoder<$inner> {
+            pub fn new(inner: $inner, level: bzip2::Compression) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::BzEncoder::new(level, 30),
+                    ),
+                }
+            }
+        });
+
+        algos!(@algo deflate ["deflate"] DeflateDecoder DeflateEncoder<$inner> {
+            pub fn new(inner: $inner, level: flate2::Compression) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::DeflateEncoder::new(level),
+                    ),
+                }
+            }
+        });
+
+        algos!(@algo gzip ["gzip"] GzipDecoder GzipEncoder<$inner> {
+            pub fn new(inner: $inner, level: flate2::Compression) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::GzipEncoder::new(level),
+                    ),
+                }
+            }
+        });
+
+        algos!(@algo zlib ["zlib"] ZlibDecoder ZlibEncoder<$inner> {
+            pub fn new(inner: $inner, level: flate2::Compression) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::ZlibEncoder::new(level),
+                    ),
+                }
+            }
+        });
+
+        algos!(@algo zstd ["zstd"] ZstdDecoder ZstdEncoder<$inner> {
+            /// The `level` argument here can range from 1-21. A level of `0` will use zstd's default, which is `3`.
+            pub fn new(inner: $inner, level: i32) -> Self {
+                Self {
+                    inner: crate::$mod::generic::Encoder::new(
+                        inner,
+                        crate::codec::ZstdEncoder::new(level),
+                    ),
+                }
+            }
+        });
+    }
+}