Little refactor of persistent library

Author: gridbugs

Cargo.toml

@@ -22,7 +22,7 @@ members = [
     "midi-udp-widgets-app-lib",
     "modules",
     "patches",
-    "persistent",
+    "persist",
     "player",
     "sdl2",
     "utils",

persistent/Cargo.toml persist/Cargo.tomlpersistent/Cargo.toml renamed to persist/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "caw_persistent"
+name = "caw_persist"
 version = "0.1.0"
 edition = "2024"
 description = "Helpers for persisting data within the CAW synthesizer framework"

persistent/src/lib.rs persist/src/lib.rspersistent/src/lib.rs renamed to persist/src/lib.rs

@@ -75,51 +75,63 @@ where
     }
 }
 
-/// The type itself knows how to save and load itself
-pub trait PersistentData: Serialize + for<'a> Deserialize<'a> {
-    const NAME: &'static str;
+/// Implement this when there may be multiple different directories where values of the type will
+/// be persisted. It's probably more convenient to just use the `&'static str` impl of this trait
+/// in such a case.
+pub trait Persist<T>
+where
+    T: Serialize + for<'a> Deserialize<'a>,
+{
+    fn name(&self) -> &'static str;
 
-    fn save(&self, title: impl AsRef<str>) -> anyhow::Result<()> {
-        save(Self::NAME, self, title)
+    fn save(&self, data: &T, title: impl AsRef<str>) -> anyhow::Result<()> {
+        save(self.name(), data, title)
     }
 
     /// Like `save` but prints a warning on failure rather than returning an error value.
-    fn save_(&self, title: impl AsRef<str>) {
-        save_(Self::NAME, self, title)
+    fn save_(&self, data: &T, title: impl AsRef<str>) {
+        save_(self.name(), data, title)
     }
 
-    fn load(title: impl AsRef<str>) -> anyhow::Result<Self> {
-        load(Self::NAME, title)
+    fn load(&self, title: impl AsRef<str>) -> anyhow::Result<T> {
+        load(self.name(), title)
     }
 
     /// Like `load` but prints a warning on failure rather than returning an error value.
-    fn load_(title: impl AsRef<str>) -> Option<Self> {
-        load_(Self::NAME, title)
+    fn load_(&self, title: impl AsRef<str>) -> Option<T> {
+        load_(self.name(), title)
     }
 }
 
-/// Knows how to save and load some type `T`
-pub trait PersistentWitness<T>
+impl<T> Persist<T> for &'static str
 where
     T: Serialize + for<'a> Deserialize<'a>,
 {
+    fn name(&self) -> &'static str {
+        self
+    }
+}
+
+/// Implement this when the type uniquely determines the directory where values of that type will
+/// be persisted.
+pub trait PersistData: Serialize + for<'a> Deserialize<'a> {
     const NAME: &'static str;
 
-    fn save(&self, data: &T, title: impl AsRef<str>) -> anyhow::Result<()> {
-        save(Self::NAME, data, title)
+    fn save(&self, title: impl AsRef<str>) -> anyhow::Result<()> {
+        Self::NAME.save(self, title)
     }
 
     /// Like `save` but prints a warning on failure rather than returning an error value.
-    fn save_(&self, data: &T, title: impl AsRef<str>) {
-        save_(Self::NAME, data, title)
+    fn save_(&self, title: impl AsRef<str>) {
+        Self::NAME.save_(self, title)
     }
 
-    fn load(&self, title: impl AsRef<str>) -> anyhow::Result<T> {
-        load(Self::NAME, title)
+    fn load(title: impl AsRef<str>) -> anyhow::Result<Self> {
+        Self::NAME.load(title)
     }
 
     /// Like `load` but prints a warning on failure rather than returning an error value.
-    fn load_(&self, title: impl AsRef<str>) -> Option<T> {
-        load_(Self::NAME, title)
+    fn load_(title: impl AsRef<str>) -> Option<Self> {
+        Self::NAME.load_(title)
     }
 }

utils/Cargo.toml

@@ -16,7 +16,7 @@ web = ["getrandom/wasm_js"]
 caw_core = { version = "0.5", path = "../core" }
 caw_builder_proc_macros = { version = "0.1", path = "../builder-proc-macros" }
 serde = { version = "1.0", features = ["serde_derive"] }
-caw_persistent = { version = "0.1", path = "../persistent" }
+caw_persist = { version = "0.1", path = "../persist" }
 rand = "0.9"
 getrandom = "0.3"
 itertools = "0.14"

utils/src/looper.rs

@@ -1,6 +1,6 @@
 use caw_builder_proc_macros::builder;
 use caw_core::{Buf, Sig, SigCtx, SigT};
-use caw_persistent::PersistentWitness;
+use caw_persist::Persist;
 use itertools::izip;
 use serde::{Deserialize, Serialize};
 
@@ -42,54 +42,51 @@ impl<T> Sequence<T> {
     }
 }
 
-struct KeyLooperPersistentWitness;
-impl<T> PersistentWitness<Sequence<Option<T>>> for KeyLooperPersistentWitness
-where
-    T: Serialize + for<'a> Deserialize<'a>,
-{
-    const NAME: &'static str = "key_looper";
-}
+const KEY_LOOPER_PERSIST: &'static str = "key_looper";
 
-pub trait KeyLooperPersist<T> {
+/// Driver for saving and loading a sequence state to a file.
+pub trait KeyLooperIo<T> {
     fn load(&self) -> Sequence<Option<T>>;
     fn save(&self, sequence: &Sequence<Option<T>>);
 }
 
-pub struct KeyLooperPersistNone;
-impl<T> KeyLooperPersist<T> for KeyLooperPersistNone {
+/// Implementation of `KeyLooperIo` which doesn't actually save or load any data.
+pub struct KeyLooperIoNull;
+impl<T> KeyLooperIo<T> for KeyLooperIoNull {
     fn load(&self) -> Sequence<Option<T>> {
         Sequence::new_with(1, || None)
     }
 
     fn save(&self, _sequence: &Sequence<Option<T>>) {}
 }
 
-pub struct KeyLooperPersistWithName(pub String);
-impl<T> KeyLooperPersist<T> for KeyLooperPersistWithName
+/// Implementation of `KeyLooperIo` which saves state into a file of a given name.
+pub struct KeyLooperIoWithName(pub String);
+impl<T> KeyLooperIo<T> for KeyLooperIoWithName
 where
     T: Serialize + for<'a> Deserialize<'a>,
 {
     fn load(&self) -> Sequence<Option<T>> {
-        if let Some(sequence) = KeyLooperPersistentWitness.load_(&self.0) {
+        if let Some(sequence) = KEY_LOOPER_PERSIST.load_(&self.0) {
             sequence
         } else {
             Sequence::new_with(1, || None)
         }
     }
 
     fn save(&self, sequence: &Sequence<Option<T>>) {
-        KeyLooperPersistentWitness.save_(sequence, &self.0)
+        KEY_LOOPER_PERSIST.save_(sequence, &self.0)
     }
 }
 
-pub struct KeyLooper<X, S, T, C, N, P>
+pub struct KeyLooper<X, S, T, C, N, I>
 where
     X: Clone,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
     C: SigT<Item = bool>,
     N: SigT<Item = u32>,
-    P: KeyLooperPersist<X>,
+    I: KeyLooperIo<X>,
 {
     sig: S,
     last_value: Option<X>,
@@ -98,17 +95,17 @@ where
     length: N,
     sequence: Sequence<S::Item>,
     buf: Vec<S::Item>,
-    persist: P,
+    io: I,
 }
 
-impl<X, S, T, C, N, P> SigT for KeyLooper<X, S, T, C, N, P>
+impl<X, S, T, C, N, I> SigT for KeyLooper<X, S, T, C, N, I>
 where
     X: Clone,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
     C: SigT<Item = bool>,
     N: SigT<Item = u32>,
-    P: KeyLooperPersist<X>,
+    I: KeyLooperIo<X>,
 {
     type Item = S::Item;
 
@@ -144,31 +141,31 @@ where
             *out = self.sequence.current().clone();
         }
         if changed_this_frame {
-            self.persist.save(&self.sequence);
+            self.io.save(&self.sequence);
         }
         &self.buf
     }
 }
 
-impl<X, S, T, C, N, P> KeyLooper<X, S, T, C, N, P>
+impl<X, S, T, C, N, I> KeyLooper<X, S, T, C, N, I>
 where
     X: Clone,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
     C: SigT<Item = bool>,
     N: SigT<Item = u32>,
-    P: KeyLooperPersist<X>,
+    I: KeyLooperIo<X>,
 {
-    fn new(sig: S, tick: T, clearing: C, length: N, persist: P) -> Sig<Self> {
+    fn new(sig: S, tick: T, clearing: C, length: N, io: I) -> Sig<Self> {
         Sig(KeyLooper {
             sig,
             last_value: None,
             tick,
             clearing,
             length,
-            sequence: persist.load(),
+            sequence: io.load(),
             buf: Vec::new(),
-            persist,
+            io,
         })
     }
 }
@@ -178,7 +175,7 @@ builder! {
     #[constructor_doc = "A looper for key presses"]
     #[generic_setter_type_name = "X"]
     #[build_fn = "KeyLooper::new"]
-    #[build_ty = "Sig<KeyLooper<V, S, T, C, N, P>>"]
+    #[build_ty = "Sig<KeyLooper<V, S, T, C, N, I>>"]
     #[extra_generic("V", "Clone")]
     pub struct KeyLooperBuilder {
         #[generic_with_constraint = "SigT<Item = Option<V>>"]
@@ -195,26 +192,26 @@ builder! {
         #[generic_name = "N"]
         #[default = 16]
         length: u32,
-        #[generic_with_constraint = "KeyLooperPersist<V>"]
-        #[default = KeyLooperPersistNone]
-        #[generic_name = "P"]
-        persist: KeyLooperPersistNone,
+        #[generic_with_constraint = "KeyLooperIo<V>"]
+        #[default = KeyLooperIoNull]
+        #[generic_name = "I"]
+        io: KeyLooperIoNull,
     }
 }
 
-impl<X, S, T, C, N, P> KeyLooperBuilder<X, S, T, C, N, P>
+impl<X, S, T, C, N, I> KeyLooperBuilder<X, S, T, C, N, I>
 where
     X: Clone + Serialize + for<'a> Deserialize<'a>,
     S: SigT<Item = Option<X>>,
     T: SigT<Item = bool>,
     C: SigT<Item = bool>,
     N: SigT<Item = u32>,
-    P: KeyLooperPersist<X>,
+    I: KeyLooperIo<X>,
 {
     pub fn persist_with_name(
         self,
         name: impl AsRef<str>,
-    ) -> KeyLooperBuilder<X, S, T, C, N, KeyLooperPersistWithName> {
+    ) -> KeyLooperBuilder<X, S, T, C, N, KeyLooperIoWithName> {
         let Self {
             sig,
             trig,
@@ -227,7 +224,7 @@ where
             trig,
             clearing,
             length,
-            persist: KeyLooperPersistWithName(name.as_ref().to_string()),
+            io: KeyLooperIoWithName(name.as_ref().to_string()),
         }
     }
 }

viz-udp-app/Cargo.toml

@@ -17,6 +17,6 @@ clap = { version = "4", features = ["derive"] }
 caw_viz_udp_app_lib = { version = "0.1", path = "../viz-udp-app-lib" }
 log = "0.4"
 caw_window_utils = { version = "0.1", path = "../window-utils" }
-caw_persistent = { version = "0.1", path = "../persistent" }
+caw_persist = { version = "0.1", path = "../persist" }
 serde = { version = "1.0", features = ["serde_derive"] }
 rgb_int = "0.1"

viz-udp-app/src/main.rs

@@ -1,11 +1,11 @@
 /// A udp client which receives visualization data from a corresponding udp server and renders
 /// visualizations in a graphical window.
 use anyhow::anyhow;
-use caw_persistent::PersistentData;
+use caw_persist::PersistData;
 use caw_viz_udp_app_lib::{blink, oscilloscope};
 use caw_window_utils::{
     font::load_font,
-    persistent::{WindowPosition, WindowSize},
+    persist::{WindowPosition, WindowSize},
 };
 use clap::{Parser, Subcommand, ValueEnum};
 use line_2d::Coord;
@@ -114,7 +114,7 @@ struct OscilloscopeUiState {
     alpha_scale: u8,
 }
 
-impl PersistentData for OscilloscopeUiState {
+impl PersistData for OscilloscopeUiState {
     const NAME: &'static str = "oscilloscope_ui";
 }
 

widgets/Cargo.toml

@@ -18,7 +18,7 @@ caw_computer_keyboard = { version = "0.4", path = "../computer-keyboard" }
 caw_keyboard = { version = "0.4", path = "../keyboard" }
 caw_sdl2 = { version = "0.1", path = "../sdl2" }
 caw_window_utils = { version = "0.1", path = "../window-utils" }
-caw_persistent = { version = "0.1", path = "../persistent" }
+caw_persist = { version = "0.1", path = "../persist" }
 itertools = "0.14"
 log = "0.4"
 serde = { version = "1.0", features = ["serde_derive"] }

widgets/src/knob.rs

@@ -1,6 +1,6 @@
 use crate::window::{TitlePosition, Window};
 use anyhow::anyhow;
-use caw_persistent::PersistentData;
+use caw_persist::PersistData;
 use line_2d::Coord;
 use midly::num::u7;
 use sdl2::{
@@ -20,7 +20,7 @@ struct State {
     value_01: f32,
 }
 
-impl PersistentData for State {
+impl PersistData for State {
     const NAME: &'static str = "knob_state";
 }
 

widgets/src/window.rs

@@ -1,8 +1,8 @@
 use anyhow::anyhow;
-use caw_persistent::PersistentData;
+use caw_persist::PersistData;
 use caw_window_utils::{
     font::{Font, load_font},
-    persistent::WindowPosition,
+    persist::WindowPosition,
 };
 use sdl2::{
     EventPump,