feat: add deduplication and fast removal to vecmap

Author: yannham

libdd-trace-utils/src/span/vec_map.rs

@@ -7,6 +7,7 @@
 //! involved. Fetching and removing a value is, on the other hand, linear time in the size of the
 //! map.
 
+use crate::span::SpanText;
 use serde::ser::{Serialize, Serializer};
 use std::borrow::Borrow;
 use std::collections::HashMap;
@@ -33,6 +34,15 @@ use std::hash::Hash;
 #[derive(Clone, Debug, PartialEq, Default)]
 pub struct VecMap<K, V>(Vec<(K, V)>);
 
+/// Values that can be replaced by a special tombstone value that makes them to be ignored later in
+/// the pipeline. This makes their removal from a [VecMap] a bit more efficient (still a linear
+/// scan, but no shifting involved). Technically equivalent to [Default], but of course having a
+/// default value doesn't mean it's suitable as a `None`-like value (typically for a `f64` metrics,
+/// being `0` and being absent are entirely different)
+pub trait Tombstone {
+    fn tombstone() -> Self;
+}
+
 impl<K, V> VecMap<K, V> {
     #[must_use]
     #[inline]
@@ -87,9 +97,9 @@ impl<K, V> VecMap<K, V> {
     }
 
     /// Remove all entries matching this key from the map. This method uses [Vec::retain], and is
-    /// thus potentially costly (like any removal in a vector-like datastructure).
-    // Note: we might implement a tombstone or option-based deletion later, if removal is a bit too
-    // costly.
+    /// thus potentially costly (like any removal in a vector-like datastructure). When applicable,
+    /// prefer [Self::remove_unset], which replaces the entry with a special value (typically an
+    /// empty string) that is treated as similar to being empty.
     #[inline]
     pub fn remove_slow<Q>(&mut self, key: &Q)
     where
@@ -128,6 +138,19 @@ impl<K, V> VecMap<K, V> {
     }
 }
 
+impl<K, V: Tombstone> VecMap<K, V> {
+    #[inline]
+    pub fn remove_unset<Q>(&mut self, key: &Q)
+    where
+        K: Borrow<Q>,
+        Q: ?Sized + PartialEq,
+    {
+        self.iter_mut()
+            .filter_map(|(k, v)| ((*k).borrow() == key).then_some(v))
+            .for_each(|v| *v = V::tombstone())
+    }
+}
+
 impl<K, V> From<Vec<(K, V)>> for VecMap<K, V> {
     fn from(vec: Vec<(K, V)>) -> Self {
         VecMap(vec)
@@ -188,6 +211,12 @@ impl<K: Serialize + Eq + Hash, V: Serialize> Serialize for VecMap<K, V> {
     }
 }
 
+impl<T: SpanText> Tombstone for T {
+    fn tombstone() -> Self {
+        Self::default()
+    }
+}
+
 #[macro_export]
 macro_rules! vec_map {
     () => { $crate::span::vec_map::VecMap::new() };
@@ -272,4 +301,11 @@ mod tests {
         assert_eq!(obj.get("a").unwrap(), 3);
         assert_eq!(obj.get("b").unwrap(), 2);
     }
+
+    #[test]
+    fn macro_construction() {
+        let m: VecMap<&str, i32> = vec_map![("a", 1), ("b", 2)];
+        assert_eq!(m.get("a"), Some(&1));
+        assert_eq!(m.get("b"), Some(&2));
+    }
 }