Add BytesMut::reserve_capacity() method (#720)

* Optimize metadata repr
* Add BytesMut::reserve_capacity() method

Author: fafhrd91

Cargo.toml

@@ -41,9 +41,9 @@ ntex-util = { path = "ntex-util" }
 
 [workspace.dependencies]
 ntex = "3.0.0-pre.11"
-ntex-bytes = "1.3.0"
+ntex-bytes = "1.4.0"
 ntex-codec = "1.1.0"
-ntex-io = "3.4.0"
+ntex-io = "3.5.0"
 ntex-net = "3.5.1"
 ntex-http = "1.0.0"
 ntex-router = "1.0.0"

ntex-bytes/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changes
 
+## [1.4.0] (2026-01-21)
+
+* Add BytesMut::reserve_capacity() method
+
+* Optimize metadata repr
+
 ## [1.3.0] (2026-01-17)
 
 * Replace BytesMut with BytesVec

ntex-bytes/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-bytes"
-version = "1.3.0"
+version = "1.4.0"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Types and traits for working with bytes (bytes crate fork)"
 documentation = "https://docs.rs/ntex-bytes"

ntex-bytes/src/buf/buf_impl.rs

@@ -911,7 +911,11 @@ mod tests {
         buf.copy_to_slice(&mut dst);
         assert_eq!(&b"hello"[..], &dst);
         assert_eq!(6, buf.remaining());
+        buf.advance(1);
+        assert_eq!(Buf::chunk(&buf), &b"world"[..]);
 
+        let mut buf = &b"hello world"[..];
+        buf.advance(5);
         let mut buf = Box::new(buf);
         assert_eq!(buf.remaining(), 6);
         assert_eq!(buf.chunk(), b" world");

ntex-bytes/src/buf/buf_mut.rs

@@ -180,13 +180,11 @@ pub trait BufMut {
         assert!(self.remaining_mut() >= src.remaining());
 
         while src.has_remaining() {
-            let l;
+            let s = src.chunk();
+            let d = self.chunk_mut();
+            let l = cmp::min(s.len(), d.len());
 
             unsafe {
-                let s = src.chunk();
-                let d = self.chunk_mut();
-                l = cmp::min(s.len(), d.len());
-
                 ptr::copy_nonoverlapping(s.as_ptr(), d.as_mut_ptr(), l);
             }
 

ntex-bytes/src/bvec.rs

@@ -465,6 +465,33 @@ impl BytesMut {
         self.storage.reserve(additional);
     }
 
+    /// Reserves capacity for inserting additional bytes into the given `BytesMut`.
+    ///
+    /// This is equivalent to calling
+    /// `BytesMut::reserve(capacity - BytesMut::remaining_mut())`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if new capacity is greater than 60bit for 64bit systems
+    /// and 28bit for 32bit systems
+    ///
+    /// # Examples
+    ///
+    /// In the following example, a new buffer is allocated.
+    ///
+    /// ```
+    /// use ntex_bytes::BytesMut;
+    ///
+    /// let mut buf = BytesMut::copy_from_slice(&b"hello"[..]);
+    /// buf.reserve_capacity(128);
+    /// assert!(buf.capacity() >= 128);
+    /// assert!(buf.len() >= 5);
+    /// ```
+    #[inline]
+    pub fn reserve_capacity(&mut self, cap: usize) {
+        self.storage.reserve_capacity(cap);
+    }
+
     /// Appends given bytes to this object.
     ///
     /// If this `BytesMut` object has not enough capacity, it is resized first.
@@ -527,7 +554,7 @@ impl Buf for BytesMut {
 impl BufMut for BytesMut {
     #[inline]
     fn remaining_mut(&self) -> usize {
-        self.capacity() - self.len()
+        self.storage.remaining()
     }
 
     #[inline]
@@ -538,12 +565,10 @@ impl BufMut for BytesMut {
 
     #[inline]
     fn chunk_mut(&mut self) -> &mut UninitSlice {
-        let len = self.len();
-
         unsafe {
             // This will never panic as `len` can never become invalid
-            let ptr = &mut self.storage.as_raw()[len..];
-            UninitSlice::from_raw_parts_mut(ptr.as_mut_ptr(), self.capacity() - len)
+            let ptr = &mut self.storage.as_ptr();
+            UninitSlice::from_raw_parts_mut(ptr.add(self.len()), self.remaining_mut())
         }
     }
 
@@ -566,7 +591,6 @@ impl BufMut for BytesMut {
 
     #[inline]
     fn put_i8(&mut self, n: i8) {
-        self.reserve(1);
         self.put_u8(n as u8);
     }
 }
@@ -601,11 +625,13 @@ unsafe impl bytes::buf::BufMut for BytesMut {
 
     #[inline]
     fn chunk_mut(&mut self) -> &mut bytes::buf::UninitSlice {
-        let len = self.len();
         unsafe {
             // This will never panic as `len` can never become invalid
             let ptr = self.storage.as_ptr();
-            bytes::buf::UninitSlice::from_raw_parts_mut(ptr.add(len), self.capacity() - len)
+            bytes::buf::UninitSlice::from_raw_parts_mut(
+                ptr.add(self.len()),
+                BufMut::remaining_mut(self),
+            )
         }
     }
 

ntex-bytes/src/lib.rs

@@ -68,6 +68,9 @@ pub use crate::bvec::BytesMut;
 pub use crate::bytes::Bytes;
 pub use crate::string::ByteString;
 
+#[doc(hidden)]
+pub use crate::storage::METADATA_SIZE;
+
 #[doc(hidden)]
 #[deprecated]
 pub type BytesVec = BytesMut;