use AtomicUsize

src/lazy_index_map.rs

@@ -3,17 +3,28 @@ use std::cmp::{Eq, PartialEq};
 use std::fmt;
 use std::hash::Hash;
 use std::slice::Iter as SliceIter;
-use std::sync::{Arc, Mutex, OnceLock};
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::OnceLock;
 
 use ahash::AHashMap;
 use smallvec::SmallVec;
 
 /// Like [IndexMap](https://docs.rs/indexmap/latest/indexmap/) but only builds the lookup map when it's needed.
-#[derive(Clone, Default)]
+#[derive(Default)]
 pub struct LazyIndexMap<K, V> {
     vec: SmallVec<[(K, V); 8]>,
     map: OnceLock<AHashMap<K, usize>>,
-    last_find: Arc<Mutex<usize>>,
+    last_find: AtomicUsize,
+}
+
+impl<K: Clone, V: Clone> Clone for LazyIndexMap<K, V> {
+    fn clone(&self) -> Self {
+        Self {
+            vec: self.vec.clone(),
+            map: OnceLock::new(),
+            last_find: AtomicUsize::new(0),
+        }
+    }
 }
 
 impl<K, V> fmt::Debug for LazyIndexMap<K, V>
@@ -39,7 +50,7 @@ where
         Self {
             vec: SmallVec::new(),
             map: OnceLock::new(),
-            last_find: Arc::new(Mutex::new(0)),
+            last_find: AtomicUsize::new(0),
         }
     }
 
@@ -70,21 +81,16 @@ where
         } else {
             // otherwise we find the value in the vec
             // we assume the most likely position for the match is at `last_find + 1`
-            match self.last_find.lock() {
-                Ok(mut last_find) => {
-                    let first_try = *last_find + 1;
-                    for i in first_try..first_try + vec_len {
-                        let index = i % vec_len;
-                        let (k, v) = &self.vec[index];
-                        if k == key {
-                            *last_find = index;
-                            return Some(v);
-                        }
-                    }
-                    None
+            let first_try = self.last_find.load(Ordering::Relaxed) + 1;
+            for i in first_try..first_try + vec_len {
+                let index = i % vec_len;
+                let (k, v) = &self.vec[index];
+                if k == key {
+                    self.last_find.store(index, Ordering::Relaxed);
+                    return Some(v);
                 }
-                Err(_) => None,
             }
+            None
         }
     }