global: replace Value enum with Cow

crates/brk_vec/src/traits/collectable.rs

@@ -20,7 +20,7 @@ where
         Ok(self
             .iter_at_(from)
             .take(to - from)
-            .map(|(_, v)| v.into_inner())
+            .map(|(_, v)| v.into_owned())
             .collect::<Vec<_>>())
     }
 

crates/brk_vec/src/traits/generic.rs

@@ -1,4 +1,5 @@
 use std::{
+    borrow::Cow,
     fs::{File, OpenOptions},
     io::{self, Seek, SeekFrom, Write},
     path::{Path, PathBuf},
@@ -6,7 +7,7 @@ use std::{
 };
 
 use arc_swap::ArcSwap;
-use brk_core::{Result, Value};
+use brk_core::Result;
 use memmap2::Mmap;
 
 use crate::{AnyVec, HEADER_OFFSET, Header};
@@ -28,11 +29,11 @@ where
     fn read_(&self, index: usize, mmap: &Mmap) -> Result<Option<T>>;
 
     #[inline]
-    fn get_or_read(&self, index: I, mmap: &Mmap) -> Result<Option<Value<T>>> {
+    fn get_or_read(&self, index: I, mmap: &Mmap) -> Result<Option<Cow<T>>> {
         self.get_or_read_(index.to_usize()?, mmap)
     }
     #[inline]
-    fn get_or_read_(&self, index: usize, mmap: &Mmap) -> Result<Option<Value<T>>> {
+    fn get_or_read_(&self, index: usize, mmap: &Mmap) -> Result<Option<Cow<T>>> {
         let stored_len = self.stored_len_(mmap);
 
         if index >= stored_len {
@@ -41,9 +42,9 @@ where
             if j >= pushed.len() {
                 return Ok(None);
             }
-            Ok(pushed.get(j).map(Value::Ref))
+            Ok(pushed.get(j).map(Cow::Borrowed))
         } else {
-            Ok(self.read_(index, mmap)?.map(Value::Owned))
+            Ok(self.read_(index, mmap)?.map(Cow::Owned))
         }
     }
 

crates/brk_vec/src/traits/iterator.rs

@@ -1,6 +1,6 @@
-use std::iter::Skip;
+use std::{borrow::Cow, iter::Skip};
 
-use brk_core::{Printable, Value};
+use brk_core::Printable;
 
 use super::{StoredIndex, StoredType};
 
@@ -34,7 +34,7 @@ pub trait BaseVecIterator: Iterator {
     }
 }
 
-pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Value<'a, Self::T>)> {
+pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Cow<'a, Self::T>)> {
     type I: StoredIndex;
     type T: StoredType + 'a;
 
@@ -44,12 +44,12 @@ pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Value<'a, Self::T>)>
     }
 
     #[inline]
-    fn get_(&mut self, i: usize) -> Option<Value<'a, Self::T>> {
+    fn get_(&mut self, i: usize) -> Option<Cow<'a, Self::T>> {
         self.next_at(i).map(|(_, v)| v)
     }
 
     #[inline]
-    fn get(&mut self, i: Self::I) -> Option<Value<'a, Self::T>> {
+    fn get(&mut self, i: Self::I) -> Option<Cow<'a, Self::T>> {
         self.get_(i.unwrap_to_usize())
     }
 
@@ -65,12 +65,12 @@ pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Value<'a, Self::T>)>
                 dbg!(self.name(), i, self.len());
                 panic!("unwrap_get_inner_")
             })
-            .into_inner()
+            .into_owned()
     }
 
     #[inline]
     fn get_inner(&mut self, i: Self::I) -> Option<Self::T> {
-        self.get_(i.unwrap_to_usize()).map(|v| v.into_inner())
+        self.get_(i.unwrap_to_usize()).map(|v| v.into_owned())
     }
 
     fn last(mut self) -> Option<Self::Item>
@@ -83,7 +83,7 @@ pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Value<'a, Self::T>)>
         }
         let i = len - 1;
         self.set_(i);
-        self.next().map(|(i, v)| (i, Value::Owned(v.into_inner())))
+        self.next()
     }
 
     fn index_type_to_string(&self) -> &'static str {
@@ -93,7 +93,7 @@ pub trait VecIterator<'a>: BaseVecIterator<Item = (Self::I, Value<'a, Self::T>)>
 
 impl<'a, I, T, Iter> VecIterator<'a> for Iter
 where
-    Iter: BaseVecIterator<Item = (I, Value<'a, T>)>,
+    Iter: BaseVecIterator<Item = (I, Cow<'a, T>)>,
     I: StoredIndex,
     T: StoredType + 'a,
 {
@@ -102,4 +102,4 @@ where
 }
 
 pub type BoxedVecIterator<'a, I, T> =
-    Box<dyn VecIterator<'a, I = I, T = T, Item = (I, Value<'a, T>)> + 'a>;
+    Box<dyn VecIterator<'a, I = I, T = T, Item = (I, Cow<'a, T>)> + 'a>;