scrobble_scrubber/persistence/
memory_storage.rs

1use async_trait::async_trait;
2use std::sync::{Arc, RwLock};
3
4use super::{
5    PendingEditsState, PendingRewriteRulesState, RewriteRulesState, SettingsState, StateStorage,
6    TimestampState,
7};
8
9/// In-memory storage implementation - perfect for WASM and testing
10#[derive(Debug)]
11pub struct MemoryStorage {
12    timestamp_state: Arc<RwLock<TimestampState>>,
13    rewrite_rules_state: Arc<RwLock<RewriteRulesState>>,
14    pending_edits_state: Arc<RwLock<PendingEditsState>>,
15    pending_rules_state: Arc<RwLock<PendingRewriteRulesState>>,
16    settings_state: Arc<RwLock<SettingsState>>,
17}
18
19#[derive(Debug, thiserror::Error)]
20pub enum MemoryStorageError {
21    #[error("Lock error: {0}")]
22    LockError(String),
23}
24
25impl MemoryStorage {
26    pub fn new() -> Self {
27        Self {
28            timestamp_state: Arc::new(RwLock::new(TimestampState::default())),
29            rewrite_rules_state: Arc::new(RwLock::new(RewriteRulesState::default())),
30            pending_edits_state: Arc::new(RwLock::new(PendingEditsState::default())),
31            pending_rules_state: Arc::new(RwLock::new(PendingRewriteRulesState::default())),
32            settings_state: Arc::new(RwLock::new(SettingsState::default())),
33        }
34    }
35
36    pub fn with_initial_rules(rules: RewriteRulesState) -> Self {
37        let storage = Self::new();
38        *storage.rewrite_rules_state.write().unwrap() = rules;
39        storage
40    }
41}
42
43impl Default for MemoryStorage {
44    fn default() -> Self {
45        Self::new()
46    }
47}
48
49#[async_trait]
50impl StateStorage for MemoryStorage {
51    type Error = MemoryStorageError;
52
53    async fn save_timestamp_state(&mut self, state: &TimestampState) -> Result<(), Self::Error> {
54        *self
55            .timestamp_state
56            .write()
57            .map_err(|e| MemoryStorageError::LockError(e.to_string()))? = state.clone();
58        Ok(())
59    }
60
61    async fn load_timestamp_state(&self) -> Result<TimestampState, Self::Error> {
62        Ok(self
63            .timestamp_state
64            .read()
65            .map_err(|e| MemoryStorageError::LockError(e.to_string()))?
66            .clone())
67    }
68
69    async fn save_rewrite_rules_state(
70        &mut self,
71        state: &RewriteRulesState,
72    ) -> Result<(), Self::Error> {
73        *self
74            .rewrite_rules_state
75            .write()
76            .map_err(|e| MemoryStorageError::LockError(e.to_string()))? = state.clone();
77        Ok(())
78    }
79
80    async fn load_rewrite_rules_state(&self) -> Result<RewriteRulesState, Self::Error> {
81        Ok(self
82            .rewrite_rules_state
83            .read()
84            .map_err(|e| MemoryStorageError::LockError(e.to_string()))?
85            .clone())
86    }
87
88    async fn save_pending_edits_state(
89        &mut self,
90        state: &PendingEditsState,
91    ) -> Result<(), Self::Error> {
92        *self
93            .pending_edits_state
94            .write()
95            .map_err(|e| MemoryStorageError::LockError(e.to_string()))? = state.clone();
96        Ok(())
97    }
98
99    async fn load_pending_edits_state(&self) -> Result<PendingEditsState, Self::Error> {
100        Ok(self
101            .pending_edits_state
102            .read()
103            .map_err(|e| MemoryStorageError::LockError(e.to_string()))?
104            .clone())
105    }
106
107    async fn save_pending_rewrite_rules_state(
108        &mut self,
109        state: &PendingRewriteRulesState,
110    ) -> Result<(), Self::Error> {
111        *self
112            .pending_rules_state
113            .write()
114            .map_err(|e| MemoryStorageError::LockError(e.to_string()))? = state.clone();
115        Ok(())
116    }
117
118    async fn load_pending_rewrite_rules_state(
119        &self,
120    ) -> Result<PendingRewriteRulesState, Self::Error> {
121        Ok(self
122            .pending_rules_state
123            .read()
124            .map_err(|e| MemoryStorageError::LockError(e.to_string()))?
125            .clone())
126    }
127
128    async fn save_settings_state(&mut self, state: &SettingsState) -> Result<(), Self::Error> {
129        *self
130            .settings_state
131            .write()
132            .map_err(|e| MemoryStorageError::LockError(e.to_string()))? = state.clone();
133        Ok(())
134    }
135
136    async fn load_settings_state(&self) -> Result<SettingsState, Self::Error> {
137        Ok(self
138            .settings_state
139            .read()
140            .map_err(|e| MemoryStorageError::LockError(e.to_string()))?
141            .clone())
142    }
143}
scrobble_scrubber/persistence/memory_storage.rs

scrobble_scrubber/persistence/
memory_storage.rs
