lset on cache

Author: Migorithm

duva/src/domains/caches/actor.rs

@@ -220,6 +220,19 @@ impl CacheActor {
             | _ => Err(anyhow::anyhow!(WRONG_TYPE_ERR_MSG)),
         }
     }
+
+    pub(crate) fn lset(
+        &mut self,
+        key: String,
+        index: isize,
+        value: String,
+    ) -> Result<(), anyhow::Error> {
+        let Some(CacheValue { value: TypedValue::List(list), .. }) = self.cache.get_mut(&key)
+        else {
+            return Err(anyhow::anyhow!(WRONG_TYPE_ERR_MSG));
+        };
+        list.lset(index, value)
+    }
 }
 
 #[derive(Clone, Debug)]

duva/src/domains/caches/cache_manager.rs

@@ -422,6 +422,21 @@ impl CacheManager {
         let value = rx.await??;
         Ok(value)
     }
+
+    pub(crate) async fn route_lset(
+        &self,
+        key: String,
+        index: isize,
+        value: String,
+        current_idx: u64,
+    ) -> Result<String> {
+        let (tx, rx) = tokio::sync::oneshot::channel();
+        self.select_shard(key.as_str())
+            .send(CacheCommand::LSet { key, index, value: value.clone(), callback: tx.into() })
+            .await?;
+        rx.await??;
+        Ok(IndexedValueCodec::encode(value, current_idx))
+    }
 }
 
 pub struct IndexedValueCodec;

duva/src/domains/caches/cache_objects/types/quicklist.rs

@@ -531,6 +531,36 @@ impl QuickList {
         }
         None
     }
+
+    pub(crate) fn lset(&mut self, index: isize, value: String) -> anyhow::Result<()> {
+        if self.len == 0 {
+            return Err(anyhow::anyhow!("List is empty"));
+        }
+
+        // Calculate absolute index
+        let len = self.len as isize;
+        let index = if index < 0 { (len + index).max(0) } else { index } as usize;
+
+        if index >= self.len {
+            return Err(anyhow::anyhow!("Index out of bounds"));
+        }
+
+        let mut current_index = 0;
+        for node in &mut self.nodes {
+            if current_index + node.entry_count > index {
+                node.ensure_decompressed(&self.fill_factor);
+                if let NodeData::Uncompressed(ziplist) = &mut node.data {
+                    let mut entries = ziplist.to_vec();
+                    if let Some(entry) = entries.get_mut(index - current_index) {
+                        *entry = Bytes::from(value.clone());
+                        return Ok(());
+                    }
+                }
+            }
+            current_index += node.entry_count;
+        }
+        Err(anyhow::anyhow!("Index not found"))
+    }
 }
 
 #[cfg(test)]

duva/src/domains/caches/command.rs

@@ -90,4 +90,10 @@ pub(crate) enum CacheCommand {
         index: isize,
         callback: Callback<anyhow::Result<CacheValue>>,
     },
+    LSet {
+        key: String,
+        index: isize,
+        value: String,
+        callback: Callback<anyhow::Result<()>>,
+    },
 }

duva/src/domains/caches/service.rs

@@ -94,6 +94,9 @@ impl CacheActor {
                 | CacheCommand::LIndex { key, index, callback } => {
                     let _ = callback.send(self.lindex(key, index));
                 },
+                | CacheCommand::LSet { key, index, value, callback } => {
+                    let _ = callback.send(self.lset(key, index, value));
+                },
             }
         }
         Ok(self)

duva/src/presentation/clients/controller.rs

@@ -209,7 +209,12 @@ impl ClientController {
             | ClientAction::LIndex { key, index } => {
                 self.cache_manager.route_lindex(key, index).await?.into()
             },
-            | ClientAction::LSet { key, index, value } => todo!(),
+            | ClientAction::LSet { key, index, value } => QueryIO::SimpleString(
+                self.cache_manager
+                    .route_lset(key, index, value, current_index.unwrap())
+                    .await?
+                    .into(),
+            ),
         };
 
         Ok(response)