Pull VBR integer method delegation out into its own VBRInteger trait

This not only maintains semver compatiblity, but it also
allows us to exclude a bool implementation altogether.

Author: tuffy

src/lib.rs

@@ -294,16 +294,6 @@ pub trait Integer {
         R: BitRead + ?Sized,
         Self: Sized;
 
-    /// Reads a valur of ourself from the stream using a variable width integer.
-    ///
-    /// # Errors
-    ///
-    /// Passes along any I/O error from the underlying stream.
-    fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
-    where
-        R: BitRead + ?Sized,
-        Self: Sized;
-
     /// Writes ourself to the stream using the given const number of bits.
     ///
     /// # Errors
@@ -329,6 +319,24 @@ pub trait Integer {
         writer: &mut W,
         bits: BitCount<MAX>,
     ) -> io::Result<()>;
+}
+
+/// This trait is for integer types which can be read or written
+/// to a bit stream as variable-width integers.
+///
+/// It unifies signed and unsigned integer types by delegating
+/// reads and write to the signed and unsigned vbr reading and
+/// writing methods as appropriate.
+pub trait VBRInteger: Integer {
+    /// Reads a value of ourself from the stream using a variable width integer.
+    ///
+    /// # Errors
+    ///
+    /// Passes along any I/O error from the underlying stream.
+    fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
+    where
+        R: BitRead + ?Sized,
+        Self: Sized;
 
     /// Writes ourself to the stream using a variable width integer.
     ///
@@ -396,15 +404,6 @@ impl Integer for bool {
         }
     }
 
-    #[inline(always)]
-    fn read_vbr<const FIELD_SIZE: u32, R>(_reader: &mut R) -> io::Result<Self>
-    where
-        R: BitRead + ?Sized,
-        Self: Sized,
-    {
-        unimplemented!("Can't read a VBR boolean")
-    }
-
     #[inline(always)]
     fn write<const BITS: u32, W: BitWrite + ?Sized>(self, writer: &mut W) -> io::Result<()> {
         const {
@@ -428,14 +427,6 @@ impl Integer for bool {
             ))
         }
     }
-
-    #[inline(always)]
-    fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(
-        self,
-        _writer: &mut W,
-    ) -> io::Result<()> {
-        unimplemented!("Can't write a VBR for boolean")
-    }
 }
 
 impl<const SIZE: usize, I: Integer + Copy + Default> Integer for [I; SIZE] {
@@ -469,6 +460,23 @@ impl<const SIZE: usize, I: Integer + Copy + Default> Integer for [I; SIZE] {
 
         Ok(a)
     }
+
+    #[inline]
+    fn write<const BITS: u32, W: BitWrite + ?Sized>(self, writer: &mut W) -> io::Result<()> {
+        IntoIterator::into_iter(self).try_for_each(|v| writer.write::<BITS, I>(v))
+    }
+
+    #[inline]
+    fn write_var<const MAX: u32, W: BitWrite + ?Sized>(
+        self,
+        writer: &mut W,
+        count: BitCount<MAX>,
+    ) -> io::Result<()> {
+        IntoIterator::into_iter(self).try_for_each(|v| writer.write_counted(count, v))
+    }
+}
+
+impl<const SIZE: usize, I: VBRInteger + Copy + Default> VBRInteger for [I; SIZE] {
     fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
     where
         R: BitRead + ?Sized,
@@ -485,20 +493,6 @@ impl<const SIZE: usize, I: Integer + Copy + Default> Integer for [I; SIZE] {
         Ok(a)
     }
 
-    #[inline]
-    fn write<const BITS: u32, W: BitWrite + ?Sized>(self, writer: &mut W) -> io::Result<()> {
-        IntoIterator::into_iter(self).try_for_each(|v| writer.write::<BITS, I>(v))
-    }
-
-    #[inline]
-    fn write_var<const MAX: u32, W: BitWrite + ?Sized>(
-        self,
-        writer: &mut W,
-        count: BitCount<MAX>,
-    ) -> io::Result<()> {
-        IntoIterator::into_iter(self).try_for_each(|v| writer.write_counted(count, v))
-    }
-
     fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(
         self,
         writer: &mut W,
@@ -701,15 +695,6 @@ macro_rules! define_unsigned_integer {
                 reader.read_unsigned_counted::<MAX, _>(bits)
             }
 
-            #[inline(always)]
-            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
-            where
-                R: BitRead + ?Sized,
-                Self: Sized,
-            {
-                reader.read_unsigned_vbr::<FIELD_SIZE, _>()
-            }
-
             #[inline(always)]
             fn write<const BITS: u32, W: BitWrite + ?Sized>(
                 self,
@@ -726,6 +711,17 @@ macro_rules! define_unsigned_integer {
             ) -> io::Result<()> {
                 writer.write_unsigned_counted(bits, self)
             }
+        }
+
+        impl VBRInteger for $t {
+            #[inline(always)]
+            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
+            where
+                R: BitRead + ?Sized,
+                Self: Sized,
+            {
+                reader.read_unsigned_vbr::<FIELD_SIZE, _>()
+            }
 
             #[inline(always)]
             fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(
@@ -804,16 +800,6 @@ macro_rules! define_unsigned_integer {
                 }
             }
 
-            #[inline]
-            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
-            where
-                R: BitRead + ?Sized,
-                Self: Sized,
-            {
-                <$t as Integer>::read_vbr::<FIELD_SIZE, R>(reader)
-                    .map(|u| NonZero::new(u + 1).unwrap())
-            }
-
             #[inline]
             fn write<const BITS: u32, W: BitWrite + ?Sized>(
                 self,
@@ -844,13 +830,25 @@ macro_rules! define_unsigned_integer {
                     ))
                 }
             }
+        }
+
+        impl VBRInteger for NonZero<$t> {
+            #[inline]
+            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
+            where
+                R: BitRead + ?Sized,
+                Self: Sized,
+            {
+                <$t as VBRInteger>::read_vbr::<FIELD_SIZE, R>(reader)
+                    .map(|u| NonZero::new(u + 1).unwrap())
+            }
 
             #[inline]
             fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(
                 self,
                 writer: &mut W,
             ) -> io::Result<()> {
-                <$t as Integer>::write_vbr::<FIELD_SIZE, W>(self.get() - 1, writer)
+                <$t as VBRInteger>::write_vbr::<FIELD_SIZE, W>(self.get() - 1, writer)
             }
         }
 
@@ -872,15 +870,6 @@ macro_rules! define_unsigned_integer {
                 <$t as Integer>::read_var::<MAX, R>(reader, count).map(NonZero::new)
             }
 
-            #[inline(always)]
-            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
-            where
-                R: BitRead + ?Sized,
-                Self: Sized,
-            {
-                <$t as Integer>::read_vbr::<FIELD_SIZE, _>(reader).map(NonZero::new)
-            }
-
             #[inline]
             fn write<const BITS: u32, W: BitWrite + ?Sized>(
                 self,
@@ -901,13 +890,24 @@ macro_rules! define_unsigned_integer {
                     count,
                 )
             }
+        }
+
+        impl VBRInteger for Option<NonZero<$t>> {
+            #[inline(always)]
+            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
+            where
+                R: BitRead + ?Sized,
+                Self: Sized,
+            {
+                <$t as VBRInteger>::read_vbr::<FIELD_SIZE, _>(reader).map(NonZero::new)
+            }
 
             #[inline]
             fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(
                 self,
                 writer: &mut W,
             ) -> io::Result<()> {
-                <$t as Integer>::write_vbr::<FIELD_SIZE, W>(
+                <$t as VBRInteger>::write_vbr::<FIELD_SIZE, W>(
                     self.map(|n| n.get()).unwrap_or(0),
                     writer,
                 )
@@ -1010,15 +1010,6 @@ macro_rules! define_signed_integer {
                 reader.read_signed_counted::<MAX, _>(bits)
             }
 
-            #[inline(always)]
-            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
-            where
-                R: BitRead + ?Sized,
-                Self: Sized,
-            {
-                reader.read_signed_vbr::<FIELD_SIZE, _>()
-            }
-
             #[inline(always)]
             fn write<const BITS: u32, W: BitWrite + ?Sized>(
                 self,
@@ -1035,6 +1026,17 @@ macro_rules! define_signed_integer {
             ) -> io::Result<()> {
                 writer.write_signed_counted::<MAX, _>(bits, self)
             }
+        }
+
+        impl VBRInteger for $t {
+            #[inline(always)]
+            fn read_vbr<const FIELD_SIZE: u32, R>(reader: &mut R) -> io::Result<Self>
+            where
+                R: BitRead + ?Sized,
+                Self: Sized,
+            {
+                reader.read_signed_vbr::<FIELD_SIZE, _>()
+            }
 
             #[inline(always)]
             fn write_vbr<const FIELD_SIZE: u32, W: BitWrite + ?Sized>(

src/read.rs

@@ -20,7 +20,7 @@ use std::io;
 
 use super::{
     BitCount, CheckablePrimitive, Endianness, Integer, PhantomData, Primitive, SignedBitCount,
-    SignedInteger, UnsignedInteger,
+    SignedInteger, UnsignedInteger, VBRInteger,
 };
 
 use core::convert::TryInto;
@@ -994,7 +994,7 @@ pub trait BitRead {
     }
 
     /// Reads a signed or unsigned variable width integer from the stream.
-    /// 
+    ///
     /// # Errors
     ///
     /// Passes along any I/O error from the underlying stream.
@@ -1010,7 +1010,7 @@ pub trait BitRead {
     /// assert_eq!(r.read_vbr::<4, i32>().unwrap(), -50);
     /// ```
     #[inline]
-    fn read_vbr<const FIELD_SIZE: u32, I: Integer>(&mut self) -> io::Result<I> {
+    fn read_vbr<const FIELD_SIZE: u32, I: VBRInteger>(&mut self) -> io::Result<I> {
         I::read_vbr::<FIELD_SIZE, _>(self)
     }
 

src/write.rs

@@ -24,7 +24,7 @@ use std::io;
 
 use super::{
     BitCount, Checkable, CheckedSigned, CheckedUnsigned, Endianness, Integer, Numeric, PhantomData,
-    Primitive, SignedBitCount, SignedInteger, UnsignedInteger,
+    Primitive, SignedBitCount, SignedInteger, UnsignedInteger, VBRInteger,
 };
 
 #[cfg(feature = "alloc")]
@@ -1050,7 +1050,7 @@ pub trait BitWrite {
     /// assert_eq!(writer.into_writer(), [0b0110_1011, 0b1100_0001]);
     /// ```
     #[inline]
-    fn write_vbr<const FIELD_SIZE: u32, I: Integer>(&mut self, value: I) -> io::Result<()> {
+    fn write_vbr<const FIELD_SIZE: u32, I: VBRInteger>(&mut self, value: I) -> io::Result<()> {
         I::write_vbr::<FIELD_SIZE, _>(value, self)
     }