Hide inner Entry structure

diff --git a/src/bin/mtbl_dump.rs b/src/bin/mtbl_dump.rs
index 4b0142b217ab1d6678c9578c7ff2eac32a67e666..c1de7244bd2920c6d71e88f6db5fcb88fa9c01c7 100644 (file)
--- a/src/bin/mtbl_dump.rs
+++ b/src/bin/mtbl_dump.rs
@@ -6,6 +6,6 @@ fn main() {
         .expect("Usage: mtbl_dump <filename>");
     let reader = mtbl::reader::from_file(fname);
     for e in reader.iter() {
-        println!("{:?}: {:?}", *e.key, *e.value);
+        println!("{:?}: {:?}", e.key(), e.value());
     }
 }

diff --git a/src/dupsort_func.rs b/src/dupsort_func.rs
index 956233c10bdaa8b444fed22c2d7c490c217a84ec..40231066b5f3ca0a1da53ccc216fde4f357bc6ce 100644 (file)
--- a/src/dupsort_func.rs
+++ b/src/dupsort_func.rs
@@ -88,7 +88,7 @@ where
 
             //   println!("2: {:?} / {:?}", self.next, self.run);
             while let Some(e) = self.iter.next() {
-                if e.key == self.run[0].key {
+                if e.key() == self.run[0].key() {
                     self.run.push(e);
                     continue;
                 }
@@ -126,7 +126,7 @@ fn test_dupsort() {
             .collect(),
     );
 
-    let s = ts.dupsort_func(|a, b| a.value[0].cmp(&b.value[0]));
+    let s = ts.dupsort_func(|a, b| a.value()[0].cmp(&b.value()[0]));
 
     assert_eq!(
         Vec::from_iter((&s).iter()),

diff --git a/src/entry.rs b/src/entry.rs
index 06d7707dc17736a81a8735282708bc224fbcafcc..491a294f5612759bbc520bee82197cab0047be0c 100644 (file)
--- a/src/entry.rs
+++ b/src/entry.rs
@@ -2,8 +2,8 @@ use std::sync::Arc;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Entry {
-    pub key: Arc<Vec<u8>>,
-    pub value: Arc<Vec<u8>>,
+    key: Arc<Vec<u8>>,
+    value: Arc<Vec<u8>>,
 }
 
 impl Entry {
@@ -27,4 +27,20 @@ impl Entry {
         Arc::make_mut(&mut self.key).clear();
         Arc::make_mut(&mut self.value).clear();
     }
+
+    pub fn key(&self) -> &[u8] {
+        self.key.as_slice()
+    }
+
+    pub fn key_mut(&mut self) -> &mut Vec<u8> {
+        Arc::make_mut(&mut self.key)
+    }
+
+    pub fn value(&self) -> &[u8] {
+        self.value.as_slice()
+    }
+
+    pub fn value_mut(&mut self) -> &mut Vec<u8> {
+        Arc::make_mut(&mut self.value)
+    }
 }

diff --git a/src/iter.rs b/src/iter.rs
index 7e062c35067cec7ed46b2ddb6dd85544ba3de37b..f92f301e44d188b2c9ceb0c95c58c2a93ee596c9 100644 (file)
--- a/src/iter.rs
+++ b/src/iter.rs
@@ -32,7 +32,7 @@ impl<I: Iter> Iterator for PrefixIter<I> {
     type Item = Entry;
     fn next(&mut self) -> Option<Self::Item> {
         let item = self.iter.next()?;
-        if item.key.starts_with(self.prefix.as_slice()) {
+        if item.key().starts_with(self.prefix.as_slice()) {
             Some(item)
         } else {
             None
@@ -67,7 +67,7 @@ impl<I: Iter> Iterator for RangeIter<I> {
     type Item = Entry;
     fn next(&mut self) -> Option<Self::Item> {
         let item = self.iter.next()?;
-        if item.key.as_slice() <= self.end.as_slice() {
+        if item.key() <= self.end.as_slice() {
             Some(item)
         } else {
             None

diff --git a/src/merge_func.rs b/src/merge_func.rs
index 1e16f0eb118cedfe52fbfc0f026a188e78e4bb46..6fa1f01b9cb9cce820e4a003e34a2c34d52e0741 100644 (file)
--- a/src/merge_func.rs
+++ b/src/merge_func.rs
@@ -1,5 +1,4 @@
 use crate::{Entry, Iter, Source};
-use std::sync::Arc;
 
 pub struct MergeFunc<S: Source, F: Fn(&mut Vec<u8>, &Entry)> {
     source: S,
@@ -66,8 +65,8 @@ where
     fn next(&mut self) -> Option<Self::Item> {
         let mut cur = self.prev.take().or_else(|| self.iter.next())?;
         while let Some(e) = self.iter.next() {
-            if e.key == cur.key {
-                (self.merge_func)(Arc::make_mut(&mut cur.value), &e);
+            if e.key() == cur.key() {
+                (self.merge_func)(cur.value_mut(), &e);
             } else {
                 self.prev.replace(e);
                 break;
@@ -101,7 +100,7 @@ fn test_merge_func() {
     );
 
     let s = ts.merge_func(|v, e| {
-        v[0] += e.value[0];
+        v[0] += e.value()[0];
     });
 
     assert_eq!(

diff --git a/src/merger.rs b/src/merger.rs
index a0bdca8f65dc181883e127cdc6729a18b6f31ed6..558a672c68cdd8fd47e405c06763e2a0997af0d5 100644 (file)
--- a/src/merger.rs
+++ b/src/merger.rs
@@ -25,20 +25,20 @@ struct MergeEntry<I: Iter> {
 
 impl<I: Iter> PartialEq for MergeEntry<I> {
     fn eq(&self, other: &Self) -> bool {
-        self.e.key == other.e.key
+        self.e.key() == other.e.key()
     }
 }
 impl<I: Iter> Eq for MergeEntry<I> {}
 
 impl<I: Iter> PartialOrd for MergeEntry<I> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(other.e.key.cmp(&self.e.key))
+        Some(other.e.key().cmp(&self.e.key()))
     }
 }
 
 impl<I: Iter> Ord for MergeEntry<I> {
     fn cmp(&self, other: &Self) -> Ordering {
-        other.e.key.cmp(&self.e.key)
+        other.e.key().cmp(&self.e.key())
     }
 }
 
@@ -81,7 +81,7 @@ impl<I: Iter> Iterator for MergeIter<I> {
             if let Some(e) = next.it.next() {
                 next.e = e;
                 self.last_key.clear();
-                self.last_key.extend(next.e.key.as_slice());
+                self.last_key.extend(next.e.key());
                 return Some(cur);
             }
         }
@@ -97,9 +97,9 @@ impl<I: Iter> Iter for MergeIter<I> {
                 match self.heap.peek_mut() {
                     None => return,
                     Some(mut head) => {
-                        if head.e.key.as_slice() >= key {
+                        if head.e.key() >= key {
                             self.last_key.clear();
-                            self.last_key.extend_from_slice(head.e.key.as_slice());
+                            self.last_key.extend_from_slice(head.e.key());
                             return;
                         }
                         head.it.seek(key);
@@ -180,7 +180,7 @@ mod test {
             v.extend(tnum(i))
         }
         v.sort();
-        let v2 = Vec::from_iter(s.iter().map(|e| e.key[0]));
+        let v2 = Vec::from_iter(s.iter().map(|e| e.key()[0]));
         assert_eq!(v2, v);
     }
 

diff --git a/src/reader/block.rs b/src/reader/block.rs
index d456f6b8ddf79520491127534f1a7cc02a2f71fa..b6abaad8dee42bb968ced6017402fb366d135648 100644 (file)
--- a/src/reader/block.rs
+++ b/src/reader/block.rs
@@ -1,7 +1,6 @@
 use crate::{Entry, Iter, Result};
 use integer_encoding::VarInt;
 use std::mem::size_of;
-use std::sync::Arc;
 
 #[derive(Debug)]
 enum RestartType {
@@ -154,10 +153,7 @@ impl<D: AsRef<[u8]>> BlockIter<D> {
         }
 
         let data = self.block.data.as_ref();
-        let entry = self.cur_ent.get_or_insert(Entry {
-            key: Arc::new(Vec::new()),
-            value: Arc::new(Vec::new()),
-        });
+        let entry = self.cur_ent.get_or_insert(Entry::new([], []));
 
         let (shared_key, len) = usize::decode_var(&data[idx..])?;
         idx += len;
@@ -166,17 +162,17 @@ impl<D: AsRef<[u8]>> BlockIter<D> {
         let (len_val, len) = usize::decode_var(&data[idx..])?;
         idx += len;
 
-        if shared_key > entry.key.len() {
+        if shared_key > entry.key().len() {
             // return Err("shared_key too long".into());
             return None;
         }
 
-        let key = Arc::make_mut(&mut entry.key);
+        let key = entry.key_mut();
         key.truncate(shared_key);
         key.extend_from_slice(get_bytes(&data[idx..], unshared_key).ok()?);
         idx += unshared_key;
 
-        let val = Arc::make_mut(&mut entry.value);
+        let val = entry.value_mut();
         val.clear();
         val.extend_from_slice(get_bytes(&data[idx..], len_val).ok()?);
         idx += len_val;
@@ -204,7 +200,7 @@ impl<D: AsRef<[u8]>> Iter for BlockIter<D> {
             match self.decode() {
                 None => break,
                 Some(e) => {
-                    if e.key.as_slice() >= key {
+                    if e.key() >= key {
                         self.off = poff;
                         return;
                     }
@@ -250,10 +246,10 @@ mod test {
         let b = build_block(n, 1, 10);
         let bi = b.into_iter();
         assert_eq!(
-            bi.map(|e| e.key).collect::<Vec<_>>(),
+            bi.map(|e| Vec::from(e.key())).collect::<Vec<_>>(),
             build_ref(n, 1)
                 .into_iter()
-                .map(|e| e.key)
+                .map(|e| Vec::from(e.key()))
                 .collect::<Vec<_>>()
         );
     }
@@ -264,8 +260,8 @@ mod test {
         let b = build_block(n, 10, 10);
         let mut bi = b.into_iter();
         bi.seek(&u32::to_be_bytes(40));
-        assert_eq!(bi.next().unwrap().key.as_ref(), &u32::to_be_bytes(40));
+        assert_eq!(bi.next().unwrap().key(), &u32::to_be_bytes(40));
         bi.seek(&u32::to_be_bytes(32));
-        assert_eq!(bi.next().unwrap().key.as_ref(), &u32::to_be_bytes(40));
+        assert_eq!(bi.next().unwrap().key(), &u32::to_be_bytes(40));
     }
 }

diff --git a/src/reader/mod.rs b/src/reader/mod.rs
index 1f31a3eb1a36706e2406e9c71609a5bf31bd23de..cf2873c205d31c7c39c3325f5a6294accedc3e63 100644 (file)
--- a/src/reader/mod.rs
+++ b/src/reader/mod.rs
@@ -160,7 +160,7 @@ impl<D: AsRef<[u8]>> Iter for ReaderIter<D> {
         self.index_iter
             .next()
             .and_then(|e| {
-                self.next_offset = usize::decode_var(e.value.as_slice())?.0;
+                self.next_offset = usize::decode_var(e.value())?.0;
                 self.next_block().map(|_| {
                     self.data_iter.as_mut().unwrap().seek(key);
                 })

diff --git a/src/sorter.rs b/src/sorter.rs
index 5012530eacee2a5cff9fd891b82a430ad7503d73..232bbfcfe04ec91bbafa24c398e3f412ec237512 100644 (file)
--- a/src/sorter.rs
+++ b/src/sorter.rs
@@ -27,7 +27,7 @@ where
     }
 
     pub fn add(&mut self, e: Entry) {
-        let esize = e.key.len() + e.value.len();
+        let esize = e.key().len() + e.value().len();
         if esize + self.batch_size > self.max_size {
             self.write_chunk();
         }
@@ -52,7 +52,7 @@ where
         let mut w = Writer::new(Vec::new());
         self.batch
             .get_mut()
-            .sort_unstable_by(|a, b| a.key.cmp(&b.key));
+            .sort_unstable_by(|a, b| a.key().cmp(b.key()));
         self.batch
             .take()
             .merge_func(&self.merge_func)

diff --git a/src/source.rs b/src/source.rs
index dd79f8855c6e1b81bbe1d5731587356d311c45ad..a9f73476cc19e2c9a38c521988c2b607339d2934 100644 (file)
--- a/src/source.rs
+++ b/src/source.rs
@@ -56,7 +56,7 @@ impl<'a> Iter for VecIter<'a> {
         let mut right = self.vec.len() - 1;
         while left < right {
             let mid = (left + right + 1) / 2;
-            if self.vec[mid].key.as_slice() < key {
+            if self.vec[mid].key() < key {
                 left = mid;
             } else {
                 right = mid - 1;
@@ -105,7 +105,7 @@ pub mod test_source {
     impl<'a> Iter for TestIter<'a> {
         fn seek(&mut self, key: &[u8]) {
             self.off = 0;
-            while self.off < self.source.0.len() && self.source.0[self.off].key.as_slice() < key {
+            while self.off < self.source.0.len() && self.source.0[self.off].key() < key {
                 self.off += 1;
             }
         }
@@ -142,21 +142,21 @@ pub mod test {
         let s = &test_source();
 
         assert_eq!(
-            Vec::from_iter(s.iter().map(|e| e.value[0])),
+            Vec::from_iter(s.iter().map(|e| e.value()[0])),
             vec![0, 1, 2, 3, 4]
         );
         assert_eq!(
-            Vec::from_iter(s.get(vec![0, 0, 1, 0].as_slice()).map(|e| e.value[0])),
+            Vec::from_iter(s.get(vec![0, 0, 1, 0].as_slice()).map(|e| e.value()[0])),
             vec![2]
         );
         assert_eq!(
-            Vec::from_iter(s.get_prefix(vec![0, 0].as_slice()).map(|e| e.value[0])),
+            Vec::from_iter(s.get_prefix(vec![0, 0].as_slice()).map(|e| e.value()[0])),
             vec![0, 1, 2]
         );
         assert_eq!(
             Vec::from_iter(
                 s.get_range(vec![0, 0, 0, 1].as_slice(), vec![0, 1, 0, 0].as_slice())
-                    .map(|e| e.value[0])
+                    .map(|e| e.value()[0])
             ),
             vec![1, 2, 3]
         );

diff --git a/src/writer/block_builder.rs b/src/writer/block_builder.rs
index 70e39d7c421ed53811cd0ab1190825de78b9b631..da6743f542bf91343a79534816c3d0d8d53f0fcc 100644 (file)
--- a/src/writer/block_builder.rs
+++ b/src/writer/block_builder.rs
@@ -124,9 +124,7 @@ mod test {
         let bi = Block::new(DataSlice::new(bb.as_slice()))
             .unwrap()
             .into_iter();
-        let vcmp = Vec::from_iter(
-            bi.map(|e| (Vec::from(e.key.as_slice()), Vec::from(e.value.as_slice()))),
-        );
+        let vcmp = Vec::from_iter(bi.map(|e| (Vec::from(e.key()), Vec::from(e.value()))));
         assert_eq!(v, vcmp);
     }
 }

diff --git a/src/writer/mod.rs b/src/writer/mod.rs
index 2da054a858e4288ba7c39b158b9c49bee1e680e8..a19f6db5009077954ce40eeffc0a86e9ab84e4ff 100644 (file)
--- a/src/writer/mod.rs
+++ b/src/writer/mod.rs
@@ -111,15 +111,15 @@ impl<W: std::io::Write> Writer<W> {
     }
 
     pub fn add(&mut self, e: Entry) -> Result<()> {
-        let est = e.key.len() + e.value.len() + 15;
+        let est = e.key().len() + e.value().len() + 15;
         if self.block.len() + est >= self.blocksize {
-            bytesep(&mut self.last_key, e.key.as_slice());
+            bytesep(&mut self.last_key, e.key());
             self.write_block()?;
         }
-        self.meta.add_entry(e.key.len(), e.value.len());
-        self.block.add(e.key.as_slice(), e.value.as_slice());
+        self.meta.add_entry(e.key().len(), e.value().len());
+        self.block.add(e.key(), e.value());
         self.last_key.clear();
-        self.last_key.extend_from_slice(e.key.as_slice());
+        self.last_key.extend_from_slice(e.key());
         Ok(())
     }
 

diff --git a/tests/rwtest.rs b/tests/rwtest.rs
index 31e9ea5441fca1515fe4118d13139a81047daaae..e3136b71f0f0f539ba266ecb40369d015a19cb79 100644 (file)
--- a/tests/rwtest.rs
+++ b/tests/rwtest.rs
@@ -26,8 +26,7 @@ fn test_write_readback() {
         rangei.collect::<Vec<_>>(),
         reference
             .into_iter()
-            .filter(|e| e.key.as_slice() >= &u32::to_be_bytes(192)
-                && e.key.as_slice() <= &u32::to_be_bytes(256))
+            .filter(|e| e.key() >= &u32::to_be_bytes(192) && e.key() <= &u32::to_be_bytes(256))
             .collect::<Vec<_>>()
     )
 }