add index map

Author: lamb

lib/src/context.rs

@@ -2,37 +2,37 @@ use crate::http::Request;
 use crate::http::Response;
 use crate::http::Time;
 use crate::Expr;
+use crate::Map;
 use crate::Value;
-use std::collections::HashMap;
 use std::fmt::Display;
 use std::fmt::Formatter;
 use std::fmt::Result;
 
 #[derive(Default)]
 pub struct Context {
-    inner: HashMap<String, Value>,
-    requests: HashMap<String, (String, Vec<Expr>)>,
+    inner: Map<String, Value>,
+    requests: Map<String, (String, Vec<Expr>)>,
     records: Vec<Record>,
 }
 
 impl Context {
     pub fn new() -> Self {
         Self {
-            inner: HashMap::new(),
-            requests: HashMap::new(),
+            inner: Map::new(),
+            requests: Map::new(),
             records: Vec::new(),
         }
     }
 
-    pub fn from(inner: HashMap<String, Value>) -> Self {
+    pub fn from(inner: Map<String, Value>) -> Self {
         Self {
             inner,
-            requests: HashMap::new(),
+            requests: Map::new(),
             records: Vec::new(),
         }
     }
 
-    pub fn extend(&mut self, requests: HashMap<String, (String, Vec<Expr>)>) {
+    pub fn extend(&mut self, requests: Map<String, (String, Vec<Expr>)>) {
         self.requests.extend(requests);
     }
 
@@ -52,7 +52,7 @@ impl Context {
         self.records.push(record);
     }
 
-    pub fn into_map(self) -> HashMap<String, Value> {
+    pub fn into_map(self) -> Map<String, Value> {
         self.inner
     }
 

lib/src/evaluator.rs

@@ -4,10 +4,10 @@ use crate::Assert;
 use crate::Context;
 use crate::Expr;
 use crate::Kind;
+use crate::Map;
 use crate::Record;
 use crate::Token;
 use crate::Value;
-use std::collections::HashMap;
 
 async fn eval_expr(expr: &Expr, context: &mut Context) -> Result<Value, String> {
     match expr {
@@ -50,7 +50,7 @@ async fn eval_array_literal(items: &[Expr], context: &mut Context) -> Result<Val
 }
 
 async fn eval_map_literal(pairs: &Vec<(Expr, Expr)>, context: &mut Context) -> Result<Value, String> {
-    let mut map = HashMap::new();
+    let mut map = Map::new();
     for (key, value) in pairs {
         let key = eval_expr(key, context).await?;
         let value = eval_expr(value, context).await?;
@@ -248,11 +248,11 @@ async fn eval_list(items: &[Expr], context: &mut Context) -> Result<Vec<Value>,
 #[cfg(test)]
 mod tests {
     use super::eval_block;
-    use crate::parser::Parser;
-    use crate::parser::Source;
     use crate::Context;
+    use crate::Map;
+    use crate::Parser;
+    use crate::Source;
     use crate::Value;
-    use std::collections::HashMap;
 
     async fn run_eval_tests(tests: Vec<(&str, Value)>) {
         for (text, expect) in tests {
@@ -423,17 +423,17 @@ mod tests {
     #[tokio::test]
     async fn test_map_literal() {
         let tests = vec![
-            ("{}", Value::Map(HashMap::new())),
+            ("{}", Value::Map(Map::new())),
             (
                 "{1: 2, 2: 3}",
-                Value::Map(HashMap::from_iter(vec![
+                Value::Map(Map::from_iter(vec![
                     (String::from("1"), Value::Integer(2)),
                     (String::from("2"), Value::Integer(3)),
                 ])),
             ),
             (
                 "{1 + 1: 2 * 2, 3 + 3: 4 * 4}",
-                Value::Map(HashMap::from_iter(vec![
+                Value::Map(Map::from_iter(vec![
                     (String::from("2"), Value::Integer(4)),
                     (String::from("6"), Value::Integer(16)),
                 ])),

lib/src/http/response.rs

@@ -1,9 +1,9 @@
 use super::Headers;
 use super::Stream;
+use crate::Map;
 use crate::Parser;
 use crate::Source;
 use crate::Value;
-use std::collections::HashMap;
 use tokio::io::AsyncBufReadExt;
 use tokio::io::AsyncReadExt;
 use tokio::io::BufReader;
@@ -75,12 +75,12 @@ impl Response {
         })
     }
 
-    pub fn to_map(&self) -> HashMap<String, Value> {
-        let mut map = HashMap::new();
+    pub fn to_map(&self) -> Map<String, Value> {
+        let mut map = Map::new();
         map.insert(String::from("version"), Value::String(self.version.to_string()));
         map.insert(String::from("status"), Value::Integer(self.status as i64));
         map.insert(String::from("reason"), Value::String(self.reason.to_string()));
-        let mut headers: HashMap<String, Value> = HashMap::new();
+        let mut headers = Map::new();
         for header in self.headers.iter() {
             match headers.get_mut(&header.name) {
                 Some(Value::Array(array)) => array.push(Value::String(header.value.to_string())),
@@ -129,7 +129,7 @@ Access-Control-Allow-Credentials: true
     assert_eq!(7, response.headers.len());
     assert_eq!("{\n  \"origin\": \"122.9.3.166\"\n}\n", response.body);
     assert_eq!(
-        Some(&Value::Map(HashMap::from_iter(vec![(
+        Some(&Value::Map(Map::from_iter(vec![(
             String::from("origin"),
             Value::String(String::from("122.9.3.166"))
         )]))),
@@ -159,7 +159,7 @@ Access-Control-Allow-Credentials: true
     assert_eq!(7, response.headers.len());
     assert_eq!("{\n  \"origin\": \"122.9.3.166\"\n}\n", response.body);
     assert_eq!(
-        Some(&Value::Map(HashMap::from_iter(vec![(
+        Some(&Value::Map(Map::from_iter(vec![(
             String::from("origin"),
             Value::String(String::from("122.9.3.166"))
         )]))),

lib/src/lib.rs

@@ -2,6 +2,7 @@ mod context;
 mod evaluator;
 mod http;
 mod lexer;
+mod map;
 mod native;
 mod parser;
 mod stat;
@@ -12,6 +13,7 @@ mod writer;
 
 use context::Assert;
 use context::Record;
+use map::Map;
 use syntax::Expr;
 use token::Kind;
 use token::Token;

lib/src/map.rs

@@ -0,0 +1,147 @@
+use std::borrow::Borrow;
+use std::collections::HashMap;
+use std::hash::Hash;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Map<K: Eq + Hash, V> {
+    indices: HashMap<K, usize>,
+    entries: Vec<V>,
+}
+
+impl<K: Eq + Hash, V: Default> Map<K, V> {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn insert(&mut self, k: K, v: V) -> Option<V> {
+        match self.indices.get(&k) {
+            Some(i) => {
+                self.entries.push(v);
+                Some(self.entries.swap_remove(*i))
+            }
+            None => {
+                self.indices.insert(k, self.entries.len());
+                self.entries.push(v);
+                None
+            }
+        }
+    }
+
+    pub fn remove<Q>(&mut self, k: &Q) -> Option<V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        match self.indices.remove(k) {
+            Some(i) => {
+                self.entries.push(V::default());
+                Some(self.entries.swap_remove(i))
+            }
+            None => None,
+        }
+    }
+
+    pub fn get<Q>(&self, k: &Q) -> Option<&V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        match self.indices.get(k) {
+            Some(i) => self.entries.get(*i),
+            None => None,
+        }
+    }
+
+    pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>
+    where
+        K: Borrow<Q>,
+        Q: Hash + Eq + ?Sized,
+    {
+        match self.indices.get(k) {
+            Some(i) => self.entries.get_mut(*i),
+            None => None,
+        }
+    }
+
+    pub fn iter(&self) -> Iter<K, V> {
+        Iter {
+            indices: self.indices.iter(),
+            entries: &self.entries,
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.indices.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.indices.len()
+    }
+
+    pub fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
+        for (k, v) in iter {
+            self.insert(k, v);
+        }
+    }
+}
+
+impl<K: Eq + Hash, V> Default for Map<K, V> {
+    fn default() -> Self {
+        Self {
+            indices: HashMap::default(),
+            entries: Vec::default(),
+        }
+    }
+}
+
+impl<K: Eq + Hash, V: Default> FromIterator<(K, V)> for Map<K, V> {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
+        let mut map = Map::default();
+        for (key, value) in iter {
+            map.insert(key, value);
+        }
+        map
+    }
+}
+
+impl<K: Eq + Hash, V: Default> IntoIterator for Map<K, V> {
+    type Item = (K, V);
+    type IntoIter = IntoIter<K, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        IntoIter {
+            indices: self.indices.into_iter(),
+            entries: self.entries,
+        }
+    }
+}
+
+pub struct IntoIter<K, V> {
+    indices: std::collections::hash_map::IntoIter<K, usize>,
+    entries: Vec<V>,
+}
+
+impl<K, V: Default> Iterator for IntoIter<K, V> {
+    type Item = (K, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (k, i) = self.indices.next()?;
+        self.entries.push(V::default());
+        let v = self.entries.swap_remove(i);
+        Some((k, v))
+    }
+}
+
+pub struct Iter<'a, K, V> {
+    indices: std::collections::hash_map::Iter<'a, K, usize>,
+    entries: &'a [V],
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+    type Item = (&'a K, &'a V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (k, &i) = self.indices.next()?;
+        self.entries.get(i).map(|v| (k, v))
+    }
+}

lib/src/parser.rs

@@ -1,13 +1,13 @@
 use crate::lexer;
 use crate::Expr;
 use crate::Kind;
+use crate::Map;
 use crate::Token;
-use std::collections::HashMap;
 
 pub struct Source {
     pub exprs: Vec<Expr>,
-    pub requests: HashMap<String, (String, Vec<Expr>)>,
-    pub tests: HashMap<String, Vec<Expr>>,
+    pub requests: Map<String, (String, Vec<Expr>)>,
+    pub tests: Map<String, Vec<Expr>>,
 }
 
 pub struct Parser {
@@ -67,8 +67,8 @@ impl Parser {
 
     pub fn parse(&mut self) -> Result<Source, String> {
         let mut exprs = Vec::new();
-        let mut requests = HashMap::new();
-        let mut tests = HashMap::new();
+        let mut requests = Map::new();
+        let mut tests = Map::new();
         while self.current_token().kind != Kind::Eof {
             match self.current_token().kind {
                 Kind::Request => {