From c8303e8d4986a8446efae0b6cac349d64809fd56 Mon Sep 17 00:00:00 2001
From: Markus Reiter <me@reitermark.us>
Date: Tue, 29 Apr 2025 12:21:23 +0200
Subject: [PATCH] Implement `bytes` traits for `VecInner`.

---
 src/bytes.rs | 40 +++++++++++++++++++++++++++++++++-------
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/src/bytes.rs b/src/bytes.rs
index a07b2612..ef638722 100644
--- a/src/bytes.rs
+++ b/src/bytes.rs
@@ -1,19 +1,22 @@
-//! Bytes implementations for heapless types
+//! Implementations of `bytes` traits for `heapless` types.
 
-use crate::{len_type::LenType, Vec};
+use crate::{
+    len_type::LenType,
+    vec::{VecInner, VecStorage},
+};
 use bytes::{buf::UninitSlice, BufMut};
 
-unsafe impl<const N: usize, LenT: LenType> BufMut for Vec<u8, N, LenT> {
+unsafe impl<S: VecStorage<u8> + ?Sized, LenT: LenType> BufMut for VecInner<u8, LenT, S> {
     #[inline]
     fn remaining_mut(&self) -> usize {
-        N - self.len()
+        self.capacity() - self.len()
     }
 
     #[inline]
     unsafe fn advance_mut(&mut self, cnt: usize) {
         let len = self.len();
         let pos = len + cnt;
-        if pos >= N {
+        if pos >= self.capacity() {
             panic!("Advance out of range");
         }
         self.set_len(pos);
@@ -23,13 +26,13 @@ unsafe impl<const N: usize, LenT: LenType> BufMut for Vec<u8, N, LenT> {
     fn chunk_mut(&mut self) -> &mut UninitSlice {
         let len = self.len();
         let ptr = self.as_mut_ptr();
-        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, N)[len..] }
+        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, self.capacity())[len..] }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::Vec;
+    use crate::{Vec, VecView};
     use bytes::BufMut;
 
     #[test]
@@ -54,4 +57,27 @@ mod tests {
         unsafe { vec.advance_mut(1) };
         assert_eq!(vec.chunk_mut().len(), 7);
     }
+
+    #[test]
+    #[should_panic]
+    fn buf_mut_advance_mut_out_of_bounds_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
+        unsafe { vec.advance_mut(9) };
+    }
+
+    #[test]
+    fn buf_mut_remaining_mut_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
+        assert_eq!(vec.remaining_mut(), 8);
+        vec.push(42).unwrap();
+        assert_eq!(vec.remaining_mut(), 7);
+    }
+
+    #[test]
+    fn buf_mut_chunk_mut_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
+        assert_eq!(vec.chunk_mut().len(), 8);
+        unsafe { vec.advance_mut(1) };
+        assert_eq!(vec.chunk_mut().len(), 7);
+    }
 }