From 98ab8254798d3b08e75116d1067b2429ea46edb9 Mon Sep 17 00:00:00 2001
From: "Aode (lion)" <asonix@asonix.dog>
Date: Sat, 5 Mar 2022 19:04:28 -0600
Subject: [PATCH] Fix examples

---
 examples/echo.rs          | 17 ++++++++---------
 examples/kinda_ok_http.rs | 23 ++++++++++-------------
 2 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/examples/echo.rs b/examples/echo.rs
index b319b2c..5aff609 100644
--- a/examples/echo.rs
+++ b/examples/echo.rs
@@ -1,11 +1,14 @@
-use jive::io::{Async, Nonblocking, ReadBytes, Readiness};
+use jive::{
+    io::{Async, Nonblocking, Readiness},
+    net::TcpListener,
+};
 use read_write_buf::ReadWriteBuf;
 use std::time::Duration;
 
 fn main() -> Result<(), jive::task::JoinError> {
     jive::block_on(async move {
         jive::spawn(async move {
-            let mut listener = match Async::bind(([127, 0, 0, 1], 3456)).await {
+            let mut listener = match Async::<TcpListener>::bind(([127, 0, 0, 1], 3456)).await {
                 Ok(listener) => listener,
                 Err(_) => return,
             };
@@ -34,19 +37,15 @@ fn main() -> Result<(), jive::task::JoinError> {
                         if readiness.is_read() {
                             while let Some(buf) = ring_buf.for_reading() {
                                 match stream.read_nonblocking(buf)? {
-                                    Nonblocking::Ready(ReadBytes::Read(n)) => {
-                                        let n: usize = n.into();
+                                    Nonblocking::Ready(n) if n > 0 => {
                                         let should_break = n < buf.len();
                                         ring_buf.advance_read(n);
                                         if should_break {
                                             break;
                                         }
                                     }
-                                    Nonblocking::Ready(ReadBytes::EOF) if ring_buf.is_empty() => {
-                                        break 'l2
-                                    }
-                                    Nonblocking::Ready(ReadBytes::EOF)
-                                    | Nonblocking::WouldBlock => break,
+                                    Nonblocking::Ready(_) if ring_buf.is_empty() => break 'l2,
+                                    Nonblocking::Ready(_) | Nonblocking::WouldBlock => break,
                                 }
                             }
 
diff --git a/examples/kinda_ok_http.rs b/examples/kinda_ok_http.rs
index 9798863..a8ffd6e 100644
--- a/examples/kinda_ok_http.rs
+++ b/examples/kinda_ok_http.rs
@@ -1,4 +1,7 @@
-use jive::io::{Async, Nonblocking, ReadBytes, Readiness};
+use jive::{
+    io::{Async, Nonblocking, Readiness},
+    net::TcpListener,
+};
 use read_write_buf::ReadWriteBuf;
 
 const CHUNKED_HEAD: &[u8] = b"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nTransfer-Encoding: chunked\r\n\r\n";
@@ -14,7 +17,7 @@ fn length_head(content_length: usize) -> Vec<u8> {
 
 fn main() {
     jive::block_on(async move {
-        let mut listener = match Async::bind(([127, 0, 0, 1], 3456)).await {
+        let mut listener = match Async::<TcpListener>::bind(([127, 0, 0, 1], 3456)).await {
             Ok(listener) => listener,
             Err(_) => return,
         };
@@ -48,8 +51,7 @@ fn main() {
                     }
 
                     match stream.read_nonblocking(&mut req_bytes[total_read..])? {
-                        Nonblocking::Ready(ReadBytes::Read(n)) => {
-                            let n = usize::from(n);
+                        Nonblocking::Ready(n) if n > 0 => {
                             total_read += n;
                             match req.parse(&req_bytes[0..n]) {
                                 Ok(httparse::Status::Complete(body_start)) => break 'l1 body_start,
@@ -64,7 +66,7 @@ fn main() {
                                 }
                             }
                         }
-                        Nonblocking::Ready(ReadBytes::EOF) => return Ok(()),
+                        Nonblocking::Ready(_) => return Ok(()),
                         Nonblocking::WouldBlock => continue,
                     }
 
@@ -152,20 +154,15 @@ fn main() {
                     if readiness.is_read() {
                         while let Some(buf) = ring_buf.for_reading() {
                             match stream.read_nonblocking(buf)? {
-                                Nonblocking::Ready(ReadBytes::Read(n)) => {
-                                    let n: usize = n.into();
+                                Nonblocking::Ready(n) if n > 0 => {
                                     let should_break = n < buf.len();
                                     ring_buf.advance_read(n);
                                     if should_break {
                                         break;
                                     }
                                 }
-                                Nonblocking::Ready(ReadBytes::EOF) if ring_buf.is_empty() => {
-                                    break 'l2
-                                }
-                                Nonblocking::Ready(ReadBytes::EOF) | Nonblocking::WouldBlock => {
-                                    break
-                                }
+                                Nonblocking::Ready(_) if ring_buf.is_empty() => break 'l2,
+                                Nonblocking::Ready(_) | Nonblocking::WouldBlock => break,
                             }
                         }