Use a separate Array enumeration

Author: ohsayan

.github/workflows/test.yml

@@ -12,6 +12,14 @@ jobs:
     steps:
       - uses: actions/checkout@v2
       - name: Build
-        run: cargo build --verbose --all-features
+        run: |
+          cargo build --verbose --no-defeault-features --features sync
+          cargo build --verbose --no-defeault-features --features sync,ssl
+          cargo build --verbose --no-defeault-features --features sync,sslv
+          cargo build --verbose --no-defeault-features --features async
+          cargo build --verbose --no-defeault-features --features async,aio-ssl
+          cargo build --verbose --no-defeault-features --features async,aio-sslv
+          cargo build --verbose --no-defeault-features --features dbg
+          cargo build --verbose --no-defeault-features --features const-gen
       - name: Run tests
         run: cargo test --all-features

src/actions.rs

@@ -61,6 +61,7 @@ pub const ERR_SNAPSHOT_DISABLED: &str = "err-snapshot-disabled";
 
 /// Errors while running actions
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum ActionError {
     /// The server sent data but we failed to parse it
     ParseError,
@@ -190,16 +191,16 @@ implement_actions!(
     /// Do note that the order might be completely meaningless
     fn lskeys(count: usize) -> Vec<FlatElement> {
         { Query::from("lskeys").arg(count)}
-        Response::Item(Element::FlatArray(arr)) => arr
+        Response::Item(Element::Array(Array::Flat(arr))) => arr
     }
     /// Get multiple keys
     ///
     /// This returns a vector of [`Element`]s which either contain the values
     /// as strings or contains `Not Found (Code: 1)` response codes
     fn mget(keys: impl IntoSkyhashAction+ 's) -> Array {
         { Query::from("mget").arg(keys)}
-        Response::Item(Element::BinArray(brr)) => Array::Bin(brr),
-        Response::Item(Element::StrArray(srr)) => Array::Str(srr)
+        Response::Item(Element::Array(Array::Bin(brr))) => Array::Bin(brr),
+        Response::Item(Element::Array(Array::Str(srr))) => Array::Str(srr)
     }
     /// Creates a snapshot
     ///
@@ -259,8 +260,8 @@ implement_actions!(
     /// Consumes the provided keys if they exist
     fn mpop(keys: impl IntoSkyhashAction + 's) -> Array {
         { Query::from("mpop").arg(keys)}
-        Response::Item(Element::BinArray(brr)) => Array::Bin(brr),
-        Response::Item(Element::StrArray(srr)) => Array::Str(srr)
+        Response::Item(Element::Array(Array::Bin(brr))) => Array::Bin(brr),
+        Response::Item(Element::Array(Array::Str(srr))) => Array::Str(srr)
     }
     /// Deletes all the provided keys if they exist or doesn't do anything at all. This method
     /// will return true if all the provided keys were deleted, else it will return false

src/deserializer.rs

@@ -27,6 +27,7 @@
 //! by Sayan Nandan and this is the first client implementation of the protocol
 //!
 
+use crate::types::Array;
 use crate::types::FlatElement;
 use crate::RespCode;
 use std::hint::unreachable_unchecked;
@@ -65,24 +66,19 @@ pub(super) struct Parser<'a> {
 /// This enum represents the data types supported by the Skyhash Protocol
 pub enum Element {
     /// Arrays can be nested! Their `<tsymbol>` is `&`
-    Array(Vec<Element>),
+    Array(Array),
     /// An unicode string value; `<tsymbol>` is `+`
     Str(String),
     /// A binary string (`?`)
     Binstr(Vec<u8>),
     /// An unsigned integer value; `<tsymbol>` is `:`
     UnsignedInt(u64),
-    /// A non-recursive array; tsymbol: `_`
-    FlatArray(Vec<FlatElement>),
     /// A response code
     RespCode(RespCode),
-    /// An array of unicode strings
-    StrArray(Vec<Option<String>>),
-    /// An array of binary strings
-    BinArray(Vec<Option<Vec<u8>>>),
 }
 
 #[derive(Debug, PartialEq)]
+#[non_exhaustive]
 /// # Parser Errors
 ///
 /// Several errors can arise during parsing and this enum accounts for them
@@ -375,16 +371,16 @@ impl<'a> Parser<'a> {
                 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::Array(Array::Recursive(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()?),
+                            b'+' => Element::Array(Array::Str(self.parse_next_typed_array_str()?)),
+                            b'?' => Element::Array(Array::Bin(self.parse_next_typed_array_bin()?)),
                             _ => return Err(ParseError::UnknownDatatype),
                         }
                     } else {
@@ -393,7 +389,7 @@ impl<'a> Parser<'a> {
                         return Err(ParseError::NotEnough);
                     }
                 }
-                b'_' => Element::FlatArray(self.parse_next_flat_array()?),
+                b'_' => Element::Array(Array::Flat(self.parse_next_flat_array()?)),
                 _ => return Err(ParseError::UnknownDatatype),
             };
             Ok(ret)
@@ -537,11 +533,11 @@ fn test_typed_str_array() {
     assert_eq!(forward, typed_array_packet.len());
     assert_eq!(
         parsed,
-        RawResponse::SimpleQuery(Element::StrArray(vec![
+        RawResponse::SimpleQuery(Element::Array(Array::Str(vec![
             Some("the".to_owned()),
             Some("cat".to_owned()),
             Some("meowed".to_owned())
-        ]))
+        ])))
     );
 }
 
@@ -552,11 +548,11 @@ fn test_typed_bin_array() {
     assert_eq!(forward, typed_array_packet.len());
     assert_eq!(
         parsed,
-        RawResponse::SimpleQuery(Element::BinArray(vec![
+        RawResponse::SimpleQuery(Element::Array(Array::Bin(vec![
             Some(Vec::from("the")),
             Some(Vec::from("cat")),
             Some(Vec::from("meowed"))
-        ]))
+        ])))
     );
 }
 
@@ -567,11 +563,11 @@ fn test_typed_bin_array_null() {
     assert_eq!(forward, typed_array_packet.len());
     assert_eq!(
         parsed,
-        RawResponse::SimpleQuery(Element::BinArray(vec![
+        RawResponse::SimpleQuery(Element::Array(Array::Bin(vec![
             Some(Vec::from("the")),
             Some(Vec::from("cat")),
             None
-        ]))
+        ])))
     );
 }
 
@@ -582,10 +578,10 @@ fn test_typed_str_array_null() {
     assert_eq!(forward, typed_array_packet.len());
     assert_eq!(
         parsed,
-        RawResponse::SimpleQuery(Element::StrArray(vec![
+        RawResponse::SimpleQuery(Element::Array(Array::Str(vec![
             Some("the".to_owned()),
             Some("cat".to_owned()),
             None
-        ]))
+        ])))
     );
 }

src/lib.rs

@@ -549,6 +549,7 @@ pub mod error {
         }
     );
     #[derive(Debug)]
+    #[non_exhaustive]
     /// An error originating from the Skyhash protocol
     pub enum SkyhashError {
         /// The server sent an invalid response
@@ -560,6 +561,7 @@ pub mod error {
     }
 
     #[derive(Debug)]
+    #[non_exhaustive]
     /// A standard error type for the client driver
     pub enum Error {
         /// An I/O error occurred

src/types.rs

@@ -76,8 +76,9 @@
 //!
 //! ```
 
-use crate::RespCode;
+use crate::Element;
 use crate::Query;
+use crate::RespCode;
 
 /// Anything that implements this trait can be turned into a [`String`]. This trait is implemented
 /// for most primitive types by default using [`std`]'s [`ToString`] trait.
@@ -273,21 +274,40 @@ impl<T: IntoSkyhashBytes> GetIterator<T> for &Vec<T> {
 }
 
 /// Array types
+#[derive(Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Array {
+    //// A binary array (typed array tsymbol `?`, `@` base tsymbol)
     Bin(Vec<Option<Vec<u8>>>),
+    /// An unicode string array (typed array tsymbol `+`, `@` base tsymbol)
     Str(Vec<Option<String>>),
+    /// A non-recursive 'flat' array (tsymbol `_`)
+    Flat(Vec<FlatElement>),
+    /// A recursive array (tsymbol `&`)
+    Recursive(Vec<Element>),
 }
 
 /// String types
+#[derive(Debug, PartialEq)]
+#[non_exhaustive]
 pub enum Str {
+    /// An unicode string
     Unicode(String),
+    /// A binary string (blob)
     Binary(Vec<u8>),
 }
 
 #[derive(Debug, PartialEq)]
+#[non_exhaustive]
+/// A _flat_ element. This corresponds to the types that can be present
+/// in a flat array as defined by the Skyhash protocol
 pub enum FlatElement {
+    /// An unicode string
     String(String),
+    /// A binary string (blob)
     Binstr(Vec<u8>),
+    /// A response code
     RespCode(RespCode),
+    /// An unsigned integer
     UnsignedInt(u64),
 }