Add BufMutSlice::(has_)spare_capacity

spare_capacity returns the total amount of unused bytes in all buffers.
And has_spare_capacity return true if that number is larger than zero.

Author: Thomasdezeeuw

src/io/mod.rs

@@ -730,6 +730,14 @@ unsafe impl<B: BufMutSlice<N>, const N: usize> BufMutSlice<N> for ReadNBuf<B> {
         self.last_read = n;
         unsafe { self.buf.set_init(n) };
     }
+
+    fn spare_capacity(&self) -> u32 {
+        self.buf.spare_capacity()
+    }
+
+    fn has_spare_capacity(&self) -> bool {
+        self.buf.has_spare_capacity()
+    }
 }
 
 /// Wrapper around a buffer `B` to skip a number of bytes.

src/io/traits.rs

@@ -270,6 +270,19 @@ pub unsafe trait BufMutSlice<const N: usize>: 'static {
     /// buffer with `n = 8` and the second with `n = 10 - 8 = 2`.
     unsafe fn set_init(&mut self, n: usize);
 
+    /// Returns the total amount of unused bytes in all buffers.
+    ///
+    /// This must be the same as the total length of all slices as returned by
+    /// [`as_iovecs_mut`].
+    ///
+    /// [`as_iovecs_mut`]: BufMutSlice::as_iovecs_mut
+    fn spare_capacity(&self) -> u32;
+
+    /// Returns `true` if any of the buffers has spare capacity.
+    fn has_spare_capacity(&self) -> bool {
+        self.spare_capacity() != 0
+    }
+
     /// Extend the buffer with `bytes`, returns the total number of bytes
     /// copied.
     ///
@@ -388,6 +401,14 @@ unsafe impl<B: BufMut, const N: usize> BufMutSlice<N> for [B; N] {
             n - left
         );
     }
+
+    fn spare_capacity(&self) -> u32 {
+        self.iter().map(BufMut::spare_capacity).sum()
+    }
+
+    fn has_spare_capacity(&self) -> bool {
+        self.iter().any(BufMut::has_spare_capacity)
+    }
 }
 
 // NOTE: Also see implementation of `BufMutSlice` for tuples in the macro
@@ -788,6 +809,14 @@ macro_rules! buf_slice_for_tuple {
                     n - left
                 );
             }
+
+            fn spare_capacity(&self) -> u32 {
+                0 $( + self.$index.spare_capacity())+
+            }
+
+            fn has_spare_capacity(&self) -> bool {
+                false $( || self.$index.has_spare_capacity())+
+            }
         }
 
         // SAFETY: `BufSlice` has the same safety requirements as `Buf` and

tests/util/mod.rs

@@ -662,6 +662,14 @@ unsafe impl BufMutSlice<2> for BadReadBufSlice {
             }
         }
     }
+
+    fn spare_capacity(&self) -> u32 {
+        unimplemented!()
+    }
+
+    fn has_spare_capacity(&self) -> bool {
+        unimplemented!()
+    }
 }
 
 // NOTE: this implementation is BROKEN! It's only used to test the write_all
@@ -679,6 +687,14 @@ unsafe impl BufMutSlice<2> for GrowingBufSlice {
         unsafe { self.data.set_init(n) };
         self.data[1].reserve(200);
     }
+
+    fn spare_capacity(&self) -> u32 {
+        unimplemented!()
+    }
+
+    fn has_spare_capacity(&self) -> bool {
+        unimplemented!()
+    }
 }
 
 // NOTE: this implementation is BROKEN! It's only used to test the