Fix Response returning dg vec instead of DataGroup

Also implemented `IntoIterator` for `DataGroup`

Author: ohsayan

src/connection.rs

@@ -16,7 +16,7 @@
 */
 
 //! # Database connections
-//! 
+//!
 //! This crate provides a [`Connection`] object that can be used to connect to a Skytable database instance
 //! and write/read queries/responses to/from it
 
@@ -25,7 +25,7 @@ use crate::{Query, Response};
 use bytes::{Buf, BytesMut};
 pub use std::io::Result as IoResult;
 use std::io::{Error, ErrorKind};
-use tokio::io::{AsyncReadExt};
+use tokio::io::AsyncReadExt;
 use tokio::net::TcpStream;
 
 /// 4 KB Read Buffer
@@ -68,13 +68,9 @@ impl Connection {
                 ClientResult::Incomplete => {
                     continue;
                 }
-                ClientResult::Response(r, f) => {
+                ClientResult::SimpleResponse(r, f) => {
                     self.buffer.advance(f);
-                    if r.len() != 1 {
-                        break Ok(Response::InvalidResponse);
-                    } else {
-                        break Ok(Response::Array(r));
-                    }
+                    break Ok(Response::Array(r));
                 }
                 ClientResult::ResponseItem(r, f) => {
                     self.buffer.advance(f);
@@ -88,6 +84,9 @@ impl Connection {
                     self.buffer.clear();
                     break Ok(Response::ParseError);
                 }
+                ClientResult::PipelinedResponse(_, _) => {
+                    todo!("Pipelined queries haven't been implemented yet!")
+                }
             }
         }
     }

src/deserializer.rs

@@ -18,7 +18,7 @@
 //! This module provides methods to deserialize an incoming response packet
 
 use crate::terrapipe::RespCode;
-use std::hint::unreachable_unchecked;
+use std::vec;
 
 #[derive(Debug, PartialEq)]
 /// A response datagroup
@@ -31,8 +31,13 @@ impl DataGroup {
     fn size(&self) -> usize {
         self.0.len()
     }
-    fn __unpack_0(mut self) -> DataType {
-        self.0.pop().unwrap()
+}
+
+impl IntoIterator for DataGroup {
+    type Item = DataType;
+    type IntoIter = vec::IntoIter<Self::Item>;
+    fn into_iter(self) -> <Self as IntoIterator>::IntoIter {
+        self.0.into_iter()
     }
 }
 
@@ -70,7 +75,9 @@ pub enum ClientResult {
     /// The response was Invalid
     InvalidResponse,
     /// The response is a valid response and has been parsed into a vector of datagroups
-    Response(Vec<DataGroup>, usize),
+    PipelinedResponse(Vec<DataGroup>, usize),
+    /// The response is a valid response and has been parsed into a datagroup
+    SimpleResponse(DataGroup, usize),
     /// A single element in a datagroup (please note that this is a client abstraction)
     ResponseItem(DataType, usize),
     /// The response was empty, which means that the remote end closed the connection
@@ -237,19 +244,13 @@ pub fn parse(buf: &[u8]) -> ClientResult {
             if items.len() == 1 {
                 if items[0].size() == 1 {
                     // Single item returned, so we can return this as ClientResult::ResponseItem
-                    ClientResult::ResponseItem(
-                        items
-                            .pop()
-                            .unwrap_or_else(|| unsafe { unreachable_unchecked() })
-                            .__unpack_0(),
-                        pos,
-                    )
+                    ClientResult::ResponseItem(items.swap_remove(0).0.swap_remove(0), pos)
                 } else {
                     // More than one time returned, so we can return this as ClientResult::Response
-                    ClientResult::Response(items, pos)
+                    ClientResult::SimpleResponse(items.swap_remove(0), pos)
                 }
             } else {
-                todo!("Pipelined queries aren't implemented yet!")
+                ClientResult::PipelinedResponse(items, pos)
             }
         } else {
             // Since the number of items we got is not equal to the action size - not all data was
@@ -317,14 +318,14 @@ fn test_parser() {
         .to_owned();
     assert_eq!(
         parse(&res),
-        ClientResult::Response(
-            vec![DataGroup(vec![
+        ClientResult::SimpleResponse(
+            DataGroup(vec![
                 DataType::RespCode(RespCode::NotFound),
                 DataType::RespCode(RespCode::Okay),
                 DataType::Str("sayan".to_owned()),
                 DataType::Str("is".to_owned()),
                 DataType::Str("busy".to_owned())
-            ])],
+            ]),
             res.len()
         )
     );

src/lib.rs

@@ -186,7 +186,7 @@ pub enum Response {
     /// The server sent an invalid response
     InvalidResponse,
     /// An array of items
-    Array(Vec<DataGroup>),
+    Array(DataGroup),
     /// A single item
     ///
     /// This is a client abstraction for a datagroup that only has one element