Add method BoundedBuf::put_slice (tokio-rs#198)

Provide a generic, safe way to copy data into a buffer, possibly
advancing the initialized length watermark.
This method is especially useful for `FixedBuf`, which lacks other
population methods available for the foreign types.

This resolves a discussion started in
tokio-rs#190 (comment)

Author: mzabaluev

src/buf/bounded.rs

@@ -1,6 +1,7 @@
 use super::{IoBuf, IoBufMut, Slice};
 
 use std::ops;
+use std::ptr;
 
 /// A possibly bounded view into an owned [`IoBuf`] buffer.
 ///
@@ -152,6 +153,29 @@ pub trait BoundedBufMut: BoundedBuf<Buf = Self::BufMut> {
     /// The caller must ensure that all bytes starting at `stable_mut_ptr()` up
     /// to `pos` are initialized and owned by the buffer.
     unsafe fn set_init(&mut self, pos: usize);
+
+    /// Copies the given byte slice into the buffer, starting at
+    /// this view's offset.
+    ///
+    /// # Panics
+    ///
+    /// If the slice's length exceeds the destination's total capacity,
+    /// this method panics.
+    fn put_slice(&mut self, src: &[u8]) {
+        assert!(self.bytes_total() >= src.len());
+        let dst = self.stable_mut_ptr();
+
+        // Safety:
+        // dst pointer validity is ensured by stable_mut_ptr;
+        // the length is checked to not exceed the view's total capacity;
+        // src (immutable) and dst (mutable) cannot point to overlapping memory;
+        // after copying the amount of bytes given by the slice, it's safe
+        // to mark them as initialized in the buffer.
+        unsafe {
+            ptr::copy_nonoverlapping(src.as_ptr(), dst, src.len());
+            self.set_init(src.len());
+        }
+    }
 }
 
 impl<T: IoBufMut> BoundedBufMut for T {

tests/fs_file.rs

@@ -1,7 +1,6 @@
 use std::{
     io::prelude::*,
     os::unix::io::{AsRawFd, FromRawFd, RawFd},
-    ptr,
 };
 
 use tempfile::NamedTempFile;
@@ -263,15 +262,15 @@ fn write_fixed() {
 
         let fixed_buf = buffers.check_out(0).unwrap();
         let mut buf = fixed_buf;
-        push_slice_to_buf(&HELLO[..6], &mut buf);
+        buf.put_slice(&HELLO[..6]);
 
         let (res, _) = file.write_fixed_at(buf, 0).await;
         let n = res.unwrap();
         assert_eq!(n, 6);
 
         let fixed_buf = buffers.check_out(1).unwrap();
         let mut buf = fixed_buf;
-        push_slice_to_buf(&HELLO[6..], &mut buf);
+        buf.put_slice(&HELLO[6..]);
 
         let (res, _) = file.write_fixed_at(buf, 6).await;
         let n = res.unwrap();
@@ -312,12 +311,3 @@ fn assert_invalid_fd(fd: RawFd) {
         res => panic!("{:?}", res),
     }
 }
-
-fn push_slice_to_buf(src: &[u8], buf: &mut impl BoundedBufMut) {
-    assert!(buf.bytes_total() >= src.len());
-    let dst = buf.stable_mut_ptr();
-    unsafe {
-        ptr::copy_nonoverlapping(src.as_ptr(), dst, src.len());
-        buf.set_init(src.len());
-    }
-}