First stab at adding async/tokio support.

1 files changed, 49 insertions, 0 deletions

diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 2ccc2cf..6f52702 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -28,6 +28,9 @@ use std::num::FpCategory;
 use std::sync::LazyLock;
 use std::vec::Vec;
 
+#[cfg(feature = "tokio")]
+use tokio::io::{AsyncReadExt,AsyncWriteExt,AsyncRead,AsyncWrite};
+
 /// Represents a value in a Gats structure.
 #[derive(PartialEq)]
 pub enum Value {
@@ -395,6 +398,17 @@ impl Value {
             Err(e) => Err(e),
         }
     }
+    
+    #[cfg(feature = "tokio")]
+    pub async fn write_packet_async<W>(&self, w: &mut W) -> Result<(), Error>
+    where
+        W: AsyncWrite + Unpin
+    {
+        match self.to_packet() {
+            Ok(body) => w.write_all(&body).await,
+            Err(e) => Err(e),
+        }
+    }
 
     pub fn bytes_to_read(r: &[u8]) -> Result<BytesToRead, Error> {
         if r.len() < 5 {
@@ -468,6 +482,35 @@ impl Value {
             }
         }
     }
+
+    #[cfg(feature = "tokio")]
+    pub async fn read_packet_async<R>(r: &mut R) -> Result<Value, Error>
+    where
+        R: AsyncRead + Unpin
+    {
+        let mut buf = Vec::<u8>::new();
+        let mut fill = 0usize;
+        loop {
+            match Value::bytes_to_read(&buf) {
+                Ok(BytesToRead::Estimate(size)) => {
+                    buf.resize(size, 0u8);
+                    let amount = r.read(&mut buf[fill..]).await?;
+                    fill += amount;
+                }
+                Ok(BytesToRead::Final(size)) => {
+                    buf.resize(size, 0u8);
+                    let amount = r.read(&mut buf[fill..]).await?;
+                    fill += amount;
+                    if fill == size {
+                        return Value::from_packet(&buf);
+                    }
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+    }
 }
 
 impl From<i64> for Value {
@@ -649,4 +692,10 @@ mod tests {
         assert!(v == v2);
         Ok(())
     }
+
+    #[cfg(feature = "tokio")]
+    #[test]
+    fn async_test() -> Result<(), Box<dyn Error>> {
+        Ok(())
+    }
 }