Introduce SharedBuf trait for Bytes VTable

src/bytes_mut.rs

@@ -13,10 +13,10 @@ use alloc::{
 };
 
 use crate::buf::{IntoIter, UninitSlice};
-use crate::bytes::Vtable;
 #[allow(unused)]
 use crate::loom::sync::atomic::AtomicMut;
 use crate::loom::sync::atomic::{AtomicPtr, AtomicUsize, Ordering};
+use crate::shared_buf::{BufferParts, SharedBuf};
 use crate::{Buf, BufMut, Bytes};
 
 /// A unique reference to a contiguous slice of memory.
@@ -253,9 +253,9 @@ impl BytesMut {
 
             let ptr = self.ptr.as_ptr();
             let len = self.len;
-            let data = AtomicPtr::new(self.data.cast());
+            let shared = self.data;
             mem::forget(self);
-            unsafe { Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE) }
+            Bytes::from_shared_buf(SharedImpl { shared, ptr, len })
         }
     }
 
@@ -1703,46 +1703,59 @@ unsafe fn rebuild_vec(ptr: *mut u8, mut len: usize, mut cap: usize, off: usize)
 
 // ===== impl SharedVtable =====
 
-static SHARED_VTABLE: Vtable = Vtable {
-    clone: shared_v_clone,
-    to_vec: shared_v_to_vec,
-    drop: shared_v_drop,
-};
+struct SharedImpl {
+    shared: *mut Shared,
+    ptr: *const u8,
+    len: usize,
+}
 
-unsafe fn shared_v_clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Bytes {
-    let shared = data.load(Ordering::Relaxed) as *mut Shared;
-    increment_shared(shared);
+unsafe impl SharedBuf for SharedImpl {
+    fn into_parts(this: Self) -> (AtomicPtr<()>, *const u8, usize) {
+        (AtomicPtr::new(this.shared.cast()), this.ptr, this.len)
+    }
 
-    let data = AtomicPtr::new(shared as *mut ());
-    Bytes::with_vtable(ptr, len, data, &SHARED_VTABLE)
-}
+    unsafe fn from_parts(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) -> Self {
+        SharedImpl {
+            shared: (data.with_mut(|p| *p)).cast(),
+            ptr,
+            len,
+        }
+    }
+
+    unsafe fn clone(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> BufferParts {
+        let shared = data.load(Ordering::Relaxed) as *mut Shared;
+        increment_shared(shared);
 
-unsafe fn shared_v_to_vec(data: &AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
-    let shared: *mut Shared = data.load(Ordering::Relaxed).cast();
+        (AtomicPtr::new(shared.cast()), ptr, len)
+    }
 
-    if (*shared).is_unique() {
-        let shared = &mut *shared;
+    unsafe fn into_vec(data: &mut AtomicPtr<()>, ptr: *const u8, len: usize) -> Vec<u8> {
+        let shared: *mut Shared = (data.with_mut(|p| *p)).cast();
 
-        // Drop shared
-        let mut vec = mem::replace(&mut shared.vec, Vec::new());
-        release_shared(shared);
+        if (*shared).is_unique() {
+            let shared = &mut *shared;
 
-        // Copy back buffer
-        ptr::copy(ptr, vec.as_mut_ptr(), len);
-        vec.set_len(len);
+            // Drop shared
+            let mut vec = mem::replace(&mut shared.vec, Vec::new());
+            release_shared(shared);
 
-        vec
-    } else {
-        let v = slice::from_raw_parts(ptr, len).to_vec();
-        release_shared(shared);
-        v
+            // Copy back buffer
+            ptr::copy(ptr, vec.as_mut_ptr(), len);
+            vec.set_len(len);
+
+            vec
+        } else {
+            let v = slice::from_raw_parts(ptr, len).to_vec();
+            release_shared(shared);
+            v
+        }
     }
-}
 
-unsafe fn shared_v_drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
-    data.with_mut(|shared| {
-        release_shared(*shared as *mut Shared);
-    });
+    unsafe fn drop(data: &mut AtomicPtr<()>, _ptr: *const u8, _len: usize) {
+        data.with_mut(|shared| {
+            release_shared(*shared as *mut Shared);
+        });
+    }
 }
 
 // compile-fails

src/impls/mod.rs

@@ -0,0 +1,3 @@
+pub mod promotable;
+pub mod shared;
+pub mod static_buf;