Implement typed arrays

Author: ohsayan

src/actions.rs

@@ -33,7 +33,7 @@
 //! use skytable::{actions::Actions, Connection};
 //! let mut con = Connection::new("127.0.0.1", 2003).unwrap();
 //! con.set("x", "100").unwrap();
-//! assert_eq!(con.get("x").unwrap(), Vec::from("100"));
+//! assert_eq!(con.get("x").unwrap(), "100");
 //!
 //! ```
 

src/deserializer.rs

@@ -75,6 +75,10 @@ pub enum Element {
     FlatArray(Vec<Vec<u8>>),
     /// A response code
     RespCode(RespCode),
+    /// An array of unicode strings
+    StrArray(Vec<String>),
+    /// An array of binary strings
+    BinArray(Vec<Vec<u8>>),
 }
 
 #[derive(Debug, PartialEq)]
@@ -325,14 +329,30 @@ impl<'a> Parser<'a> {
     fn parse_next_element(&mut self) -> ParseResult<Element> {
         if let Some(tsymbol) = self.buffer.get(self.cursor) {
             // so we have a tsymbol; nice, let's match it
-            // but advance the cursor before doing that
+            // but advance the cursor before doing that (skip)
             self.incr_cursor();
             let ret = match *tsymbol {
                 b'?' => Element::Binstr(self.parse_next_binstr()?),
                 b'+' => Element::Str(self.parse_next_string()?),
                 b':' => Element::UnsignedInt(self.parse_next_u64()?),
                 b'&' => Element::Array(self.parse_next_array()?),
                 b'!' => Element::RespCode(self.parse_next_respcode()?),
+                b'@' => {
+                    // hmmm, a typed array; let's check the tsymbol
+                    if let Some(array_type) = self.buffer.get(self.cursor) {
+                        // got tsymbol, let's skip it
+                        self.incr_cursor();
+                        match array_type {
+                            b'+' => Element::StrArray(self.parse_next_typed_array_str()?),
+                            b'?' => Element::BinArray(self.parse_next_typed_array_bin()?),
+                            _ => return Err(ParseError::UnknownDatatype),
+                        }
+                    } else {
+                        // if we couldn't fetch a tsymbol, there wasn't enough
+                        // data left
+                        return Err(ParseError::NotEnough);
+                    }
+                }
                 b'_' => Element::FlatArray(self.parse_next_flat_array()?),
                 _ => return Err(ParseError::UnknownDatatype),
             };
@@ -342,6 +362,37 @@ impl<'a> Parser<'a> {
             Err(ParseError::NotEnough)
         }
     }
+    /// The cursor should have passed the `@+` chars
+    fn parse_next_typed_array_str(&mut self) -> ParseResult<Vec<String>> {
+        let (start, stop) = self.read_line();
+        if let Some(our_size_chunk) = self.buffer.get(start..stop) {
+            // so we have a size chunk; let's get the size
+            let array_size = Self::parse_into_usize(our_size_chunk)?;
+            let mut array = Vec::with_capacity(array_size);
+            for _ in 0..array_size {
+                // no tsymbol, just elements and their sizes
+                array.push(self.parse_next_string()?);
+            }
+            Ok(array)
+        } else {
+            Err(ParseError::NotEnough)
+        }
+    }
+    /// The cursor should have passed the `@?` chars
+    fn parse_next_typed_array_bin(&mut self) -> ParseResult<Vec<Vec<u8>>> {
+        let (start, stop) = self.read_line();
+        if let Some(our_size_chunk) = self.buffer.get(start..stop) {
+            // got size chunk, let's get the size
+            let array_size = Self::parse_into_usize(our_size_chunk)?;
+            let mut array = Vec::with_capacity(array_size);
+            for _ in 0..array_size {
+                array.push(self.parse_next_binstr()?);
+            }
+            Ok(array)
+        } else {
+            Err(ParseError::NotEnough)
+        }
+    }
     /// The cursor should have passed the tsymbol
     fn parse_next_flat_array(&mut self) -> ParseResult<Vec<Vec<u8>>> {
         let (start, stop) = self.read_line();
@@ -427,3 +478,33 @@ impl<'a> Parser<'a> {
         }
     }
 }
+
+#[test]
+fn test_typed_str_array() {
+    let typed_array_packet = "*1\n@+3\n3\nthe\n3\ncat\n6\nmeowed\n".as_bytes();
+    let (parsed, forward) = Parser::new(typed_array_packet).parse().unwrap();
+    assert_eq!(forward, typed_array_packet.len());
+    assert_eq!(
+        parsed,
+        RawResponse::SimpleQuery(Element::StrArray(vec![
+            "the".to_owned(),
+            "cat".to_owned(),
+            "meowed".to_owned()
+        ]))
+    );
+}
+
+#[test]
+fn test_typed_bin_array() {
+    let typed_array_packet = "*1\n@?3\n3\nthe\n3\ncat\n6\nmeowed\n".as_bytes();
+    let (parsed, forward) = Parser::new(typed_array_packet).parse().unwrap();
+    assert_eq!(forward, typed_array_packet.len());
+    assert_eq!(
+        parsed,
+        RawResponse::SimpleQuery(Element::BinArray(vec![
+            Vec::from("the"),
+            Vec::from("cat"),
+            Vec::from("meowed")
+        ]))
+    );
+}

src/lib.rs

@@ -57,7 +57,7 @@
 //!     let mut con = Connection::new("127.0.0.1", 2003)?;
 //!     let query = Query::from("heya");
 //!     let res = con.run_simple_query(&query)?;
-//!     assert_eq!(res, Response::Item(Element::String(Vec::from("HEY"))));
+//!     assert_eq!(res, Response::Item(Element::Binstr(Vec::from("HEY"))));
 //!     Ok(())
 //! }
 //! ```
@@ -154,6 +154,7 @@ cfg_sync!(
 ///
 /// ## Example (sync)
 /// ```no_run
+/// use skytable::ConnectionBuilder;
 /// let con =
 ///     ConnectionBuilder::new()
 ///     .set_host("127.0.0.1")
@@ -163,13 +164,17 @@ cfg_sync!(
 /// ```
 ///
 /// ## Example (async)
-/// ```no_run
-/// let con =
-///     ConnectionBuilder::new()
-///     .set_host("127.0.0.1")
-///     .set_port(2003)
-///     .get_async_connection()
-///     .unwrap();
+/// ```no_test
+/// use skytable::ConnectionBuilder;
+/// async fn main() {
+///     let con =
+///         ConnectionBuilder::new()
+///         .set_host("127.0.0.1")
+///         .set_port(2003)
+///         .get_async_connection()
+///         .await
+///         .unwrap();
+/// }
 /// ```
 pub struct ConnectionBuilder<'a> {
     port: Option<u16>,