doc work etc

jamsocket · Aug 31, 2024 · d81b80f · d81b80f
1 parent bafac2e
commit d81b80f
Show file tree

Hide file tree

Showing 37 changed files with 2,147 additions and 898 deletions.
diff --git a/README.md b/README.md
@@ -30,10 +30,10 @@ implements `StateMachine` and has the following properties:
 Here's an example `StateMachine` implementing a counter:
 
 ```rust
-use aper::{StateMachine, NeverConflict};
+use aper::{Aper, AperSync};
 use serde::{Serialize, Deserialize};
 
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
+#[derive(Serialize, Deserialize, Clone, Debug, Default, AperSync)]
 struct Counter { value: i64 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
@@ -43,7 +43,7 @@ enum CounterTransition {
     Decrement(i64),
 }
 
-impl StateMachine for Counter {
+impl Aper for Counter {
     type Transition = CounterTransition;
     type Conflict = NeverConflict;
 

diff --git a/aper-stateroom/src/state_program.rs b/aper-stateroom/src/state_program.rs
@@ -1,5 +1,5 @@
 use crate::IntentEvent;
-use aper::{Aper, Attach, TreeMap, TreeMapRef};
+use aper::{Aper, AperSync, TreeMap, TreeMapRef};
 use serde::{de::DeserializeOwned, Serialize};
 
 /// This trait can be added to a [StateMachine] which takes a [TransitionEvent] as
@@ -44,7 +44,7 @@ where
     SM: Aper + Send + Sync + 'static,
     <SM as Aper>::Intent: Send;
 
-impl<SM> Attach for StateMachineContainerProgram<SM>
+impl<SM> AperSync for StateMachineContainerProgram<SM>
 where
     SM: Aper + Send + Sync + 'static,
     SM::Intent: Send,

diff --git a/aper/aper-derive/src/lib.rs b/aper/aper-derive/src/lib.rs
@@ -4,7 +4,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use std::collections::BTreeSet;
 
-#[proc_macro_derive(Attach)]
+#[proc_macro_derive(AperSync)]
 pub fn attach_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let state = MacroState::from_tokens(input.into());
     let result = state.generate_impl();
@@ -55,7 +55,7 @@ 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::Attach::attach(treemap.child(#name))
+                        #field: aper::AperSync::attach(treemap.child(#name))
                     }
                 });
                 quote! {
@@ -68,7 +68,7 @@ impl MacroState {
                 let fields = (0..*fields).map(|i| {
                     let i = Literal::byte_string(i.to_be_bytes().as_slice());
                     quote! {
-                        aper::Attach::attach(treemap.child(#i))
+                        aper::AperSync::attach(treemap.child(#i))
                     }
                 });
                 quote! {
@@ -81,7 +81,7 @@ impl MacroState {
         };
 
         quote! {
-            impl aper::Attach for #name {
+            impl aper::AperSync for #name {
                 fn attach(treemap: aper::TreeMapRef) -> Self {
                     #fields
                 }
@@ -104,7 +104,7 @@ mod tests {
         let result = state.generate_impl();
 
         let expected = quote! {
-            impl aper::Attach for MyStruct {
+            impl aper::AperSync for MyStruct {
                 fn attach(treemap: aper::TreeMapRef) -> Self {
                     MyStruct
                 }
@@ -127,11 +127,11 @@ mod tests {
         let result = state.generate_impl();
 
         let expected = quote! {
-            impl aper::Attach for MyStruct {
+            impl aper::AperSync for MyStruct {
                 fn attach(treemap: aper::TreeMapRef) -> Self {
                     MyStruct {
-                        field1: aper::Attach::attach(treemap.child(b"field1")),
-                        field2: aper::Attach::attach(treemap.child(b"field2"))
+                        field1: aper::AperSync::attach(treemap.child(b"field1")),
+                        field2: aper::AperSync::attach(treemap.child(b"field2"))
                     }
                 }
             }
@@ -150,11 +150,11 @@ mod tests {
         let result = state.generate_impl();
 
         let expected = quote! {
-            impl aper::Attach for MyStruct {
+            impl aper::AperSync for MyStruct {
                 fn attach(treemap: aper::TreeMapRef) -> Self {
                     MyStruct(
-                        aper::Attach::attach(treemap.child(b"\0\0\0\0\0\0\0\0")),
-                        aper::Attach::attach(treemap.child(b"\0\0\0\0\0\0\0\x01"))
+                        aper::AperSync::attach(treemap.child(b"\0\0\0\0\0\0\0\0")),
+                        aper::AperSync::attach(treemap.child(b"\0\0\0\0\0\0\0\x01"))
                     )
                 }
             }

diff --git a/aper/src/aper.rs b/aper/src/aper.rs
@@ -9,15 +9,15 @@ use std::{
     fmt::Debug,
 };
 
-pub trait Attach {
+pub trait AperSync {
     fn attach(map: TreeMapRef) -> Self;
 
     fn listen<F: Fn() -> bool + 'static + Send + Sync>(&self, listener: F) {
         // Default implementation does nothing.
     }
 }
 
-pub trait Aper: Attach {
+pub trait Aper: AperSync {
     type Intent: Clone + Serialize + for<'de> Deserialize<'de> + PartialEq;
     type Error: Debug;
 

diff --git a/aper/src/data_structures/atom.rs b/aper/src/data_structures/atom.rs
@@ -1,12 +1,12 @@
-use crate::{Attach, TreeMap, TreeMapRef};
+use crate::{AperSync, TreeMap, TreeMapRef};
 use serde::{de::DeserializeOwned, Serialize};
 
 pub struct Atom<T: Serialize + DeserializeOwned + Default> {
     map: TreeMapRef,
     _phantom: std::marker::PhantomData<T>,
 }
 
-impl<T: Serialize + DeserializeOwned + Default> Attach for Atom<T> {
+impl<T: Serialize + DeserializeOwned + Default> AperSync for Atom<T> {
     fn attach(map: TreeMapRef) -> Self {
         Self {
             map,

diff --git a/aper/src/data_structures/atom_map.rs b/aper/src/data_structures/atom_map.rs
@@ -0,0 +1,39 @@
+use crate::{AperSync, TreeMapRef};
+use serde::{de::DeserializeOwned, Serialize};
+
+pub struct AtomMap<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> {
+    map: TreeMapRef,
+    _phantom: std::marker::PhantomData<(K, V)>,
+}
+
+impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> AperSync for AtomMap<K, V> {
+    fn attach(map: TreeMapRef) -> Self {
+        Self {
+            map,
+            _phantom: std::marker::PhantomData,
+        }
+    }
+
+    fn listen<F: Fn() -> bool + 'static + Send + Sync>(&self, listener: F) {
+        self.map.listen(listener)
+    }
+}
+
+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())
+            .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(),
+        );
+    }
+
+    pub fn delete(&mut self, key: &K) {
+        self.map.delete(bincode::serialize(key).unwrap());
+    }
+}
diff --git a/aper/src/data_structures/fixed_array.rs b/aper/src/data_structures/fixed_array.rs
@@ -1,4 +1,4 @@
-use crate::{Attach, TreeMapRef};
+use crate::{AperSync, TreeMapRef};
 use serde::{de::DeserializeOwned, Serialize};
 
 #[derive(Clone)]
@@ -7,7 +7,7 @@ pub struct FixedArray<const N: u32, T: Serialize + DeserializeOwned + Default> {
     _phantom: std::marker::PhantomData<T>,
 }
 
-impl<const N: u32, T: Serialize + DeserializeOwned + Default> Attach for FixedArray<N, T> {
+impl<const N: u32, T: Serialize + DeserializeOwned + Default> AperSync for FixedArray<N, T> {
     fn attach(map: TreeMapRef) -> Self {
         Self {
             map,

diff --git a/aper/src/data_structures/map.rs b/aper/src/data_structures/map.rs
@@ -1,12 +1,12 @@
-use crate::{Attach, TreeMapRef};
+use crate::{AperSync, TreeMapRef};
 use serde::{de::DeserializeOwned, Serialize};
 
-pub struct Map<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> {
+pub struct Map<K: Serialize + DeserializeOwned, V: AperSync> {
     map: TreeMapRef,
     _phantom: std::marker::PhantomData<(K, V)>,
 }
 
-impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> Attach for Map<K, V> {
+impl<K: Serialize + DeserializeOwned, V: AperSync> AperSync for Map<K, V> {
     fn attach(map: TreeMapRef) -> Self {
         Self {
             map,
@@ -19,21 +19,14 @@ impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> Attach fo
     }
 }
 
-impl<K: Serialize + DeserializeOwned, V: Serialize + DeserializeOwned> Map<K, V> {
+impl<K: Serialize + DeserializeOwned, V: AperSync> Map<K, V> {
     pub fn get(&self, key: &K) -> Option<V> {
-        self.map
-            .get(&bincode::serialize(key).unwrap())
-            .map(|bytes| bincode::deserialize(&bytes).unwrap())
+        let key = bincode::serialize(key).unwrap();
+        Some(V::attach(self.map.child(&key)))
     }
 
-    pub fn set(&mut self, key: &K, value: &V) {
-        self.map.set(
-            bincode::serialize(key).unwrap(),
-            bincode::serialize(value).unwrap(),
-        );
-    }
-
-    pub fn delete(&mut self, key: &K) {
-        self.map.delete(bincode::serialize(key).unwrap());
+    pub fn get_or_create(&self, key: &K) -> V {
+        let key = bincode::serialize(key).unwrap();
+        V::attach(self.map.child(&key))
     }
 }
diff --git a/aper/src/data_structures/mod.rs b/aper/src/data_structures/mod.rs
@@ -1,3 +1,9 @@
 pub mod atom;
+pub mod atom_map;
 pub mod fixed_array;
 pub mod map;
+
+pub use atom::Atom;
+pub use atom_map::AtomMap;
+pub use fixed_array::FixedArray;
+pub use map::Map;
diff --git a/aper/src/lib.rs b/aper/src/lib.rs
@@ -7,7 +7,7 @@ mod listener;
 mod treemap;
 
 pub use aper::*;
-pub use aper_derive::Attach;
+pub use aper_derive::AperSync;
 use serde::{Deserialize, Serialize};
 pub use treemap::*;
 

diff --git a/aper/tests/backtrack.rs b/aper/tests/backtrack.rs
@@ -1,9 +1,9 @@
-use aper::{data_structures::map::Map, Attach, TreeMap, TreeMapRef};
+use aper::{data_structures::atom_map::AtomMap, AperSync, TreeMap, TreeMapRef};
 
 #[test]
 fn test_backtrack() {
     let treemap = TreeMap::default();
-    let mut map = Map::<u8, u8>::attach(TreeMapRef::new_root(&treemap));
+    let mut map = AtomMap::<u8, u8>::attach(TreeMapRef::new_root(&treemap));
 
     {
         map.set(&1, &2);

diff --git a/aper/tests/listener.rs b/aper/tests/listener.rs
@@ -1,11 +1,11 @@
 use aper::{
     data_structures::{atom::Atom, fixed_array::FixedArray},
-    Aper, AperClient, Attach, Mutation,
+    Aper, AperClient, AperSync, Mutation,
 };
 use serde::{Deserialize, Serialize};
 use std::sync::mpsc::channel;
 
-#[derive(Attach)]
+#[derive(AperSync)]
 struct SimpleStruct {
     atom_i32: Atom<i32>,
     atom_string: Atom<String>,
@@ -107,7 +107,7 @@ fn test_mutate_listener_simple() {
     assert!(fixed_array_recv.try_recv().is_err());
 }
 
-#[derive(Attach)]
+#[derive(AperSync)]
 struct LinkedFields {
     lhs: Atom<i32>,
     rhs: Atom<i32>,

diff --git a/aper/tests/simple-client-server.rs b/aper/tests/simple-client-server.rs
@@ -1,9 +1,9 @@
-use aper::{data_structures::atom::Atom, Aper, AperClient, AperServer, Attach, TreeMapRef};
+use aper::{data_structures::atom::Atom, Aper, AperClient, AperServer, AperSync, TreeMapRef};
 use serde::{Deserialize, Serialize};
 
 struct Counter(Atom<u64>);
 
-impl Attach for Counter {
+impl AperSync for Counter {
     fn attach(map: TreeMapRef) -> Self {
         Self(Atom::attach(map))
     }

diff --git a/aper/tests/tic-tac-toe.rs b/aper/tests/tic-tac-toe.rs
@@ -1,10 +1,10 @@
 use aper::{
     data_structures::{atom::Atom, fixed_array::FixedArray},
-    Aper, Attach, TreeMap, TreeMapRef,
+    Aper, AperSync, TreeMap, TreeMapRef,
 };
 use serde::{Deserialize, Serialize};
 
-#[derive(Attach)]
+#[derive(AperSync)]
 struct TicTacToe {
     grid: FixedArray<9, Option<TicTacToePlayer>>,
     player: Atom<TicTacToePlayer>,

diff --git a/examples/counter-leptos/.gitignore b/examples/counter-leptos/.gitignore
@@ -0,0 +1,2 @@
+static-client
+client-pkg