feat: add stats command

src/avl.rs

@@ -34,10 +34,13 @@ impl<T: Ord + Clone + Sync + Send, U: Clone + Sync + Send> Memtable<T, U> for Av
     fn search(&self, key: &T) -> Option<&U> {
         self.root.as_ref().map_or(None, |node| node.search(key))
     }
+    fn to_vec(&self) -> Vec<(&T, &U)> {
+        self.iter().collect()
+    }
 }
 
-impl<'a, T: 'a + Ord + Clone + Sync + Send, U: Clone + Sync + Send> AvlTreeMap<T, U> {
-    fn iter(&'a self) -> AvlTreeSetIter<'a, T, U> {
+impl<T: Ord + Clone + Sync + Send, U: Clone + Sync + Send> AvlTreeMap<T, U> {
+    fn iter(&self) -> AvlTreeSetIter<'_, T, U> {
         AvlTreeSetIter {
             prev_nodes: Vec::new(),
             current_tree: &self.root,

src/command.rs

@@ -1,20 +1,24 @@
-use crate::command::Command::{Delete, Get, Set};
+use crate::command::Command::{Delete, Get, Set, Stats};
 use crate::value::Value;
 
 pub enum Command {
     Set { key: String, value: Value },
     Get { key: String },
     Delete { key: String },
+    Stats {},
 }
 
-pub fn new_command_set<'a>(key: String, value: Value) -> Command {
-    return Set { key, value };
-}
-
-pub fn new_command_get(key: String) -> Command {
-    return Get { key };
-}
-
-pub fn new_command_delete(key: String) -> Command {
-    return Delete { key };
+impl Command {
+    pub fn new_set(key: String, value: Value) -> Self {
+        Set { key, value }
+    }
+    pub fn new_get(key: String) -> Self {
+        Get { key }
+    }
+    pub fn new_delete(key: String) -> Self {
+        Delete { key }
+    }
+    pub fn new_stats() -> Self {
+        Stats {}
+    }
 }

src/decoder.rs

@@ -1,4 +1,4 @@
-use crate::command;
+use crate::command::Command;
 use crate::value::Value;
 use std::io;
 use std::io::BufRead;
@@ -13,7 +13,7 @@ pub fn new<R: io::Read>(reader: R) -> Decoder<R> {
 }
 
 impl<R: io::Read> Decoder<R> {
-    pub fn decode(&mut self) -> Result<command::Command, io::Error> {
+    pub fn decode(&mut self) -> Result<Command, io::Error> {
         let mut buf = String::new();
         let nbytes = self.reader.read_line(&mut buf)?;
         if nbytes == 0 {
@@ -29,14 +29,15 @@ impl<R: io::Read> Decoder<R> {
                 &"set" => self.decode_set(commands),
                 &"get" => self.decode_get(commands),
                 &"delete" => self.decode_delete(commands),
+                &"stats" => Ok(Command::new_stats()),
                 _ => Err(io::Error::new(
                     io::ErrorKind::InvalidInput,
                     format!("unknown command: {}\n", c),
                 )),
             })
     }
 
-    fn decode_set(&mut self, commands: Vec<&str>) -> Result<command::Command, io::Error> {
+    fn decode_set(&mut self, commands: Vec<&str>) -> Result<Command, io::Error> {
         if commands.len() != 5 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
@@ -59,27 +60,27 @@ impl<R: io::Read> Decoder<R> {
             return Err(io::Error::new(io::ErrorKind::UnexpectedEof, "got eof\n"));
         }
         let value = Value::new(buf.trim().parse().unwrap(), flags, exptime);
-        Ok(command::new_command_set(key.to_string(), value))
+        Ok(Command::new_set(key.to_string(), value))
     }
 
-    fn decode_get(&mut self, commands: Vec<&str>) -> Result<command::Command, io::Error> {
+    fn decode_get(&self, commands: Vec<&str>) -> Result<Command, io::Error> {
         if commands.len() != 2 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
                 "get command length must be 2\n",
             ));
         }
-        let _key = commands[1];
-        Ok(command::new_command_get(_key.to_string()))
+        let key = commands[1];
+        Ok(Command::new_get(key.to_string()))
     }
-    fn decode_delete(&mut self, commands: Vec<&str>) -> Result<command::Command, io::Error> {
+    fn decode_delete(&self, commands: Vec<&str>) -> Result<Command, io::Error> {
         if commands.len() != 2 {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidInput,
                 "delete command length must be 2\n",
             ));
         }
-        let _key = commands[1];
-        Ok(command::new_command_delete(_key.to_string()))
+        let key = commands[1];
+        Ok(Command::new_delete(key.to_string()))
     }
 }

src/executor.rs

@@ -29,7 +29,7 @@ impl Executor {
                 file.write(&binary)?;
                 let binary_len = binary.len() as i32;
                 file.write(&binary_len.to_le_bytes())?;
-                memtable.write()?.insert(key, value);
+                memtable.insert(key, value);
                 Ok("STORED".to_string())
             }
             Command::Get { key } => {
@@ -51,6 +51,10 @@ impl Executor {
                 memtable.delete(&key);
                 Ok("DELETED".to_string())
             }
+            Command::Stats {} => {
+                let memtable = self.memtable.read()?;
+                Ok(format!("STAT curr_items {}", memtable.to_vec().len()))
+            },
         }
     }
 }

src/memtable.rs

@@ -2,4 +2,5 @@ pub trait Memtable<T, U>: Sync + Send {
     fn insert(&mut self, key: T, value: U);
     fn delete(&mut self, key: &T);
     fn search(&self, key: &T) -> Option<&U>;
+    fn to_vec(&self) -> Vec<(&T, &U)>;
 }

src/value.rs

@@ -34,8 +34,7 @@ impl Value {
         let data = String::from_utf8(vec[index..(index + data_len)].to_vec())?;
 
         index -= size_of::<usize>();
-        let exptime =
-            usize::from_le_bytes(vec[index..(index + size_of::<usize>())].try_into()?);
+        let exptime = usize::from_le_bytes(vec[index..(index + size_of::<usize>())].try_into()?);
 
         index -= size_of::<usize>();
         let flags = usize::from_le_bytes(vec[index..(index + size_of::<usize>())].try_into()?);