Merge pull request #44 from jamsocket/paulgb/iterator

iterator progress
jamsocket · Sep 4, 2024 · a8ffb3a · a8ffb3a
2 parents e879162 + 8ad83c4
commit a8ffb3a
Show file tree

Hide file tree

Showing 16 changed files with 376 additions and 127 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/aper/Cargo.toml b/aper/Cargo.toml
@@ -17,3 +17,4 @@ aper_derive = {path = "./aper-derive", version="0.5.0"}
 chrono = { version = "0.4.38", features = ["serde"] }
 tracing = "0.1.40"
 self_cell = "1.0.4"
+bytes = { version = "1.7.1", features = ["serde"] }
diff --git a/aper/aper-derive/src/lib.rs b/aper/aper-derive/src/lib.rs
@@ -55,7 +55,9 @@ impl MacroState {
                     let field = syn::Ident::new(field, proc_macro2::Span::call_site());
                     let name = Literal::byte_string(field.to_string().as_bytes());
                     quote! {
-                        #field: aper::AperSync::attach(store.child(#name))
+                        #field: aper::AperSync::attach(store.child(
+                            aper::Bytes::from_static(#name)
+                        ))
                     }
                 });
                 quote! {
@@ -68,7 +70,9 @@ impl MacroState {
                 let fields = (0..*fields).map(|i| {
                     let i = Literal::byte_string(i.to_be_bytes().as_slice());
                     quote! {
-                        aper::AperSync::attach(store.child(#i))
+                        aper::AperSync::attach(store.child(
+                            aper::Bytes::from_static(#i)
+                        ))
                     }
                 });
                 quote! {
@@ -130,8 +134,8 @@ mod tests {
             impl aper::AperSync for MyStruct {
                 fn attach(mut store: aper::StoreHandle) -> Self {
                     MyStruct {
-                        field1: aper::AperSync::attach(store.child(b"field1")),
-                        field2: aper::AperSync::attach(store.child(b"field2"))
+                        field1: aper::AperSync::attach(store.child(aper::Bytes::from_static(b"field1"))),
+                        field2: aper::AperSync::attach(store.child(aper::Bytes::from_static(b"field2")))
                     }
                 }
             }
@@ -153,8 +157,8 @@ mod tests {
             impl aper::AperSync for MyStruct {
                 fn attach(mut store: aper::StoreHandle) -> Self {
                     MyStruct(
-                        aper::AperSync::attach(store.child(b"\0\0\0\0\0\0\0\0")),
-                        aper::AperSync::attach(store.child(b"\0\0\0\0\0\0\0\x01"))
+                        aper::AperSync::attach(store.child(aper::Bytes::from_static(b"\0\0\0\0\0\0\0\0"))),
+                        aper::AperSync::attach(store.child(aper::Bytes::from_static(b"\0\0\0\0\0\0\0\x01")))
                     )
                 }
             }

diff --git a/aper/src/aper.rs b/aper/src/aper.rs
@@ -4,15 +4,12 @@ use crate::{
     Mutation,
 };
 use serde::{Deserialize, Serialize};
-use std::{
-    collections::{HashSet, VecDeque},
-    fmt::Debug,
-};
+use std::{collections::VecDeque, fmt::Debug};
 
 pub trait AperSync {
     fn attach(map: StoreHandle) -> Self;
 
-    fn listen<F: Fn() -> bool + 'static + Send + Sync>(&self, listener: F) {
+    fn listen<F: Fn() -> bool + 'static + Send + Sync>(&self, _listener: F) {
         // Default implementation does nothing.
     }
 }

diff --git a/aper/src/connection.rs b/aper/src/connection.rs
@@ -4,11 +4,7 @@ use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
 use std::{
     borrow::Borrow,
-    cell::RefCell,
-    sync::{
-        atomic::{AtomicU32, AtomicU64},
-        Arc, Mutex,
-    },
+    sync::{atomic::AtomicU32, Arc, Mutex},
 };
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -226,7 +222,7 @@ impl<A: Aper> ServerHandle<A> {
                     }
                 }
             }
-            MessageToServer::RequestState { latest_version } => {
+            MessageToServer::RequestState { .. } => {
                 let server = self.server.lock().unwrap();
                 let c = server.borrow();
                 let mutations = c.state_snapshot();

diff --git a/aper/src/data_structures/atom.rs b/aper/src/data_structures/atom.rs
@@ -1,4 +1,5 @@
-use crate::{AperSync, Store, StoreHandle};
+use crate::{AperSync, StoreHandle};
+use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 
 pub struct Atom<T: Serialize + DeserializeOwned + Default> {
@@ -22,12 +23,15 @@ impl<T: Serialize + DeserializeOwned + Default> AperSync for Atom<T> {
 impl<T: Serialize + DeserializeOwned + Default> Atom<T> {
     pub fn get(&self) -> T {
         self.map
-            .get(&vec![])
+            .get(&Bytes::new())
             .map(|bytes| bincode::deserialize(&bytes).expect("Couldn't deserialize"))
             .unwrap_or_default()
     }
 
     pub fn set(&mut self, value: T) {
-        self.map.set(vec![], bincode::serialize(&value).unwrap());
+        self.map.set(
+            Bytes::new(),
+            Bytes::from(bincode::serialize(&value).unwrap()),
+        );
     }
 }
diff --git a/aper/src/data_structures/atom_map.rs b/aper/src/data_structures/atom_map.rs
@@ -1,4 +1,5 @@
-use crate::{AperSync, StoreHandle};
+use crate::{AperSync, StoreHandle, StoreIterator};
+use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 
 pub struct AtomMap<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> {
@@ -22,18 +23,67 @@ impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> AperSync
 impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> AtomMap<K, V> {
     pub fn get(&self, key: &K) -> Option<V> {
         self.map
-            .get(&bincode::serialize(key).unwrap())
+            .get(&Bytes::from(bincode::serialize(key).unwrap()))
             .map(|bytes| bincode::deserialize(&bytes).unwrap())
     }
 
     pub fn set(&mut self, key: &K, value: &V) {
         self.map.set(
-            bincode::serialize(key).unwrap(),
-            bincode::serialize(value).unwrap(),
+            Bytes::from(bincode::serialize(key).unwrap()),
+            Bytes::from(bincode::serialize(value).unwrap()),
         );
     }
 
     pub fn delete(&mut self, key: &K) {
-        self.map.delete(bincode::serialize(key).unwrap());
+        self.map
+            .delete(Bytes::from(bincode::serialize(key).unwrap()));
+    }
+
+    pub fn iter(&self) -> AtomMapIter<K, V> {
+        AtomMapIter {
+            iter: self.map.iter(),
+            _phantom: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct AtomMapIter<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> {
+    iter: StoreIterator,
+    _phantom: std::marker::PhantomData<(K, V)>,
+}
+
+impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> Iterator
+    for AtomMapIter<K, V>
+{
+    type Item = (K, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let n = self.iter.next()?;
+        let key = bincode::deserialize(&n.0).unwrap();
+        let value = bincode::deserialize(&n.1).unwrap();
+        Some((key, value))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn atom_map_iter() {
+        let store = crate::Store::default();
+        let mut map = AtomMap::<String, String>::attach(store.handle());
+
+        map.set(&"h-insert".to_string(), &"b".to_string());
+        map.set(&"a-insert".to_string(), &"a".to_string());
+        map.set(&"z-insert".to_string(), &"c".to_string());
+        map.set(&"f-insert".to_string(), &"d".to_string());
+
+        let mut iter = map.iter();
+
+        assert_eq!(iter.next(), Some(("a-insert".to_string(), "a".to_string())));
+        assert_eq!(iter.next(), Some(("f-insert".to_string(), "d".to_string())));
+        assert_eq!(iter.next(), Some(("h-insert".to_string(), "b".to_string())));
+        assert_eq!(iter.next(), Some(("z-insert".to_string(), "c".to_string())));
     }
 }
diff --git a/aper/src/data_structures/fixed_array.rs b/aper/src/data_structures/fixed_array.rs
@@ -1,4 +1,5 @@
 use crate::{AperSync, StoreHandle};
+use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 
 #[derive(Clone)]
@@ -22,7 +23,7 @@ impl<const N: u32, T: Serialize + DeserializeOwned + Default> AperSync for Fixed
 
 impl<const N: u32, T: Serialize + DeserializeOwned + Default> FixedArray<N, T> {
     pub fn get(&self, index: u32) -> T {
-        if let Some(bytes) = self.map.get(&index.to_be_bytes().to_vec()) {
+        if let Some(bytes) = self.map.get(&Bytes::from(index.to_be_bytes().to_vec())) {
             bincode::deserialize(&bytes).unwrap()
         } else {
             T::default()
@@ -31,8 +32,9 @@ impl<const N: u32, T: Serialize + DeserializeOwned + Default> FixedArray<N, T> {
 
     pub fn set(&mut self, index: u32, value: T) {
         assert!(index < N);
-        let value = bincode::serialize(&value).unwrap();
-        self.map.set(index.to_be_bytes().to_vec(), value);
+        let value = Bytes::from(bincode::serialize(&value).unwrap());
+        self.map
+            .set(Bytes::from(index.to_be_bytes().to_vec()), value);
     }
 
     pub fn iter(&self) -> FixedArrayIterator<T> {
@@ -61,7 +63,7 @@ impl<T: Serialize + DeserializeOwned + Default> Iterator for FixedArrayIterator<
         }
 
         let key = self.index.to_be_bytes().to_vec();
-        let value = self.tree_ref.get(&key);
+        let value = self.tree_ref.get(&Bytes::from(key));
         self.index += 1;
 
         Some(

diff --git a/aper/src/data_structures/map.rs b/aper/src/data_structures/map.rs
@@ -1,4 +1,5 @@
 use crate::{AperSync, StoreHandle};
+use bytes::Bytes;
 use serde::{de::DeserializeOwned, Serialize};
 
 pub struct Map<K: Serialize + DeserializeOwned, V: AperSync> {
@@ -22,16 +23,16 @@ impl<K: Serialize + DeserializeOwned, V: AperSync> AperSync for Map<K, V> {
 impl<K: Serialize + DeserializeOwned, V: AperSync> Map<K, V> {
     pub fn get(&mut self, key: &K) -> Option<V> {
         let key = bincode::serialize(key).unwrap();
-        Some(V::attach(self.map.child(&key)))
+        Some(V::attach(self.map.child(Bytes::from(key))))
     }
 
     pub fn get_or_create(&mut self, key: &K) -> V {
         let key = bincode::serialize(key).unwrap();
-        V::attach(self.map.child(&key))
+        V::attach(self.map.child(Bytes::from(key)))
     }
 
     pub fn delete(&mut self, key: &K) {
         let key = bincode::serialize(key).unwrap();
-        self.map.delete_child(&key);
+        self.map.delete_child(Bytes::from(key));
     }
 }
diff --git a/aper/src/lib.rs b/aper/src/lib.rs
@@ -1,4 +1,4 @@
-#![allow(unused, clippy::type_complexity)]
+#![allow(clippy::type_complexity)]
 
 mod aper;
 pub mod connection;
@@ -8,6 +8,7 @@ mod store;
 
 pub use aper::*;
 pub use aper_derive::AperSync;
+pub use bytes::Bytes;
 use serde::{Deserialize, Serialize};
 pub use store::*;
 
@@ -16,5 +17,3 @@ pub struct Mutation {
     pub prefix: Vec<Bytes>,
     pub entries: PrefixMap,
 }
-
-pub type Bytes = Vec<u8>;