Prepare v0.2.0

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "parsenic"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 license = "Apache-2.0 OR BSL-1.0 OR MIT"
 description = "A simple no-std/no-alloc I/O and parsing crate"

src/io/destination.rs

@@ -36,20 +36,14 @@ where
 
 impl<D, T> Destination for Pin<D>
 where
-    // FIXME: Can relax `Unpin` bounds after
-    // https://github.com/rust-lang/rust/issues/86918
-    D: DerefMut<Target = T> + Unpin,
-    T: Destination + Unpin,
+    D: DerefMut<Target = T>,
+    T: Destination,
 {
     fn poll_send(
-        mut self: Pin<&mut Self>,
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &[u8],
     ) -> Poll<LostResult<usize>> {
-        <D::Target as Destination>::poll_send(
-            Pin::new(self.as_mut().get_mut()),
-            cx,
-            buf,
-        )
+        <D::Target as Destination>::poll_send(self.as_deref_mut(), cx, buf)
     }
 }

src/io/seek.rs

@@ -57,9 +57,7 @@ where
 
 impl<S, T> Seek for Pin<S>
 where
-    // FIXME: Can relax `Unpin` bounds after
-    // https://github.com/rust-lang/rust/issues/86918
-    S: DerefMut<Target = T> + Unpin,
+    S: DerefMut<Target = T>,
     T: Seek + Unpin,
 {
     fn seek(&mut self, pos: u64) {

src/io/sender.rs

@@ -1,6 +1,9 @@
+use core::{future, pin::Pin};
+
 use crate::{
+    error::{FlushError, FullError},
     io::{Destination, Seek, Truncate},
-    result::FlushResult,
+    result::{FlushResult, LostResult},
 };
 
 /// [`slice`] buffered sender.
@@ -38,13 +41,52 @@ where
     ///
     /// May not send the full amount of bytes until either the buffer is full or
     /// [`flush()`](Self::flush()) is called.
-    pub async fn send(&mut self, bytes: &[u8]) -> FlushResult {
-        todo!("{bytes:?}") // FIXME
+    pub async fn send(&mut self, bytes: &[u8]) -> LostResult<usize> {
+        let mut total_sent = 0;
+
+        for byte in bytes.iter().cloned() {
+            if self.cursor == BUF {
+                self.cursor = 0;
+
+                let sent = future::poll_fn(|cx| {
+                    Pin::new(&mut self.destination)
+                        .poll_send(cx, self.buffer.as_ref())
+                })
+                .await?;
+
+                total_sent += sent;
+
+                if sent != BUF {
+                    return Ok(total_sent);
+                }
+            }
+
+            self.buffer[self.cursor] = byte;
+            self.cursor += 1;
+        }
+
+        Ok(total_sent)
     }
 
     /// Send buffered data with the destination.
     pub async fn flush(&mut self) -> FlushResult {
-        todo!() // FIXME
+        let old_cursor = self.cursor;
+        let sent = future::poll_fn(|cx| {
+            Pin::new(&mut self.destination)
+                .poll_send(cx, &self.buffer[..self.cursor])
+        })
+        .await?;
+
+        self.cursor -= sent;
+
+        if self.cursor != 0 {
+            self.buffer.copy_within(sent..old_cursor, 0);
+            return Err(FlushError::Full(FullError::from_remaining(
+                self.cursor,
+            )));
+        }
+
+        Ok(())
     }
 }
 

src/io/source.rs

@@ -36,16 +36,14 @@ where
 
 impl<S, T> Source for Pin<S>
 where
-    // FIXME: Can relax `Unpin` bounds after
-    // https://github.com/rust-lang/rust/issues/86918
-    S: DerefMut<Target = T> + Unpin,
-    T: Source + Unpin,
+    S: DerefMut<Target = T>,
+    T: Source,
 {
     fn poll_recv(
-        mut self: Pin<&mut Self>,
+        self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         buf: &mut [u8],
     ) -> Poll<LostResult<usize>> {
-        <S::Target as Source>::poll_recv(Pin::new(&mut **self), cx, buf)
+        <S::Target as Source>::poll_recv(self.as_deref_mut(), cx, buf)
     }
 }

src/io/truncate.rs

@@ -25,9 +25,7 @@ where
 
 impl<T, U> Truncate for Pin<T>
 where
-    // FIXME: Can relax `Unpin` bounds after
-    // https://github.com/rust-lang/rust/issues/86918
-    T: DerefMut<Target = U> + Unpin,
+    T: DerefMut<Target = U>,
     U: Truncate + Unpin,
 {
     fn truncate(&mut self) {