Read to string (compio-rs#413)

* add read_to_string

* add read_to_string_at

* try to return origin String when read_to_string failed

* fix: use unchecked because the buffer is empty

---------

Co-authored-by: Yuyi Wang <Strawberry_Str@hotmail.com>

Author: Sherlock-Holo

compio-io/src/read/ext.rs

@@ -1,5 +1,6 @@
 #[cfg(feature = "allocator_api")]
 use std::alloc::Allocator;
+use std::{io, io::ErrorKind};
 
 use compio_buf::{BufResult, IntoInner, IoBuf, IoBufMut, IoVectoredBufMut, t_alloc};
 
@@ -141,6 +142,31 @@ macro_rules! loop_read_to_end {
     }};
 }
 
+#[inline]
+fn after_read_to_string(res: io::Result<usize>, buf: Vec<u8>) -> BufResult<usize, String> {
+    match res {
+        Err(err) => {
+            // we have to clear the read bytes if it is not valid utf8 bytes
+            let buf = String::from_utf8(buf).unwrap_or_else(|err| {
+                let mut buf = err.into_bytes();
+                buf.clear();
+
+                // Safety: the buffer is empty
+                unsafe { String::from_utf8_unchecked(buf) }
+            });
+
+            BufResult(Err(err), buf)
+        }
+        Ok(n) => match String::from_utf8(buf) {
+            Err(err) => BufResult(
+                Err(std::io::Error::new(ErrorKind::InvalidData, err)),
+                String::new(),
+            ),
+            Ok(data) => BufResult(Ok(n), data),
+        },
+    }
+}
+
 /// Implemented as an extension trait, adding utility methods to all
 /// [`AsyncRead`] types. Callers will tend to import this trait instead of
 /// [`AsyncRead`].
@@ -161,6 +187,12 @@ pub trait AsyncReadExt: AsyncRead {
         loop_read_exact!(buf, buf.buf_capacity(), read, loop self.read(buf.slice(read..)));
     }
 
+    /// Read all bytes as [`String`] until underlying reader reaches `EOF`.
+    async fn read_to_string(&mut self, buf: String) -> BufResult<usize, String> {
+        let BufResult(res, buf) = self.read_to_end(buf.into_bytes()).await;
+        after_read_to_string(res, buf)
+    }
+
     /// Read all bytes until underlying reader reaches `EOF`.
     async fn read_to_end<#[cfg(feature = "allocator_api")] A: Allocator + 'static>(
         &mut self,
@@ -238,6 +270,13 @@ pub trait AsyncReadAtExt: AsyncReadAt {
         );
     }
 
+    /// Read all bytes as [`String`] until EOF in this source, placing them into
+    /// `buffer`.
+    async fn read_to_string_at(&mut self, buf: String, pos: u64) -> BufResult<usize, String> {
+        let BufResult(res, buf) = self.read_to_end_at(buf.into_bytes(), pos).await;
+        after_read_to_string(res, buf)
+    }
+
     /// Read all bytes until EOF in this source, placing them into `buffer`.
     ///
     /// All bytes read from this source will be appended to the specified buffer

compio-io/tests/io.rs

@@ -364,6 +364,17 @@ fn read_to_end() {
     })
 }
 
+#[test]
+fn read_to_string() {
+    block_on(async {
+        let mut src = ReadOne(Cursor::new("test".to_string().into_bytes()));
+
+        let (len, buf) = src.read_to_string(String::new()).await.unwrap();
+        assert_eq!(len, 4);
+        assert_eq!(buf, "test");
+    })
+}
+
 struct ReadOneAt(Vec<u8>);
 
 impl AsyncReadAt for ReadOneAt {
@@ -401,6 +412,19 @@ fn read_to_end_at() {
     })
 }
 
+#[test]
+fn read_to_string_at() {
+    block_on(async {
+        let mut src = vec![1, 1];
+        src.extend_from_slice("test".as_bytes());
+        let mut src = ReadOneAt(src);
+
+        let (len, buf) = src.read_to_string_at(String::new(), 2).await.unwrap();
+        assert_eq!(len, 4);
+        assert_eq!(buf, "test");
+    })
+}
+
 #[test]
 fn split_unsplit() {
     block_on(async {