cleanup subspace

Author: bluejekyll

foundationdb/src/subspace.rs

@@ -68,16 +68,16 @@ impl Subspace {
     /// removed.  `unpack` will return an error if the key is not in this Subspace or does not
     /// encode a well-formed Tuple.
     pub fn unpack<T: Tuple>(&self, key: &[u8]) -> Result<T, TupleError> {
-        if !self.contains(key) {
+        if !self.covers(key) {
             return Err(TupleError::InvalidData);
         }
         let key = &key[self.prefix.len()..];
         Tuple::decode(&key)
     }
 
-    /// `contains` returns true if the provided key starts with the prefix of this Subspace,
+    /// `covers` returns true if the provided key starts with the prefix of this Subspace,
     /// indicating that the Subspace logically contains the key.
-    pub fn contains(&self, key: &[u8]) -> bool {
+    pub fn covers(&self, key: &[u8]) -> bool {
         key.starts_with(&self.prefix)
     }
 
@@ -124,13 +124,13 @@ mod tests {
     }
 
     #[test]
-    fn contains() {
+    fn covers() {
         let ss0 = Subspace::new(&(1,));
         let ss1 = Subspace::new(&(2,));
         let tup = (2, 3);
 
-        assert!(ss0.contains(&ss0.pack(&tup)));
-        assert!(!ss1.contains(&ss0.pack(&tup)));
+        assert!(ss0.covers(&ss0.pack(&tup)));
+        assert!(!ss1.covers(&ss0.pack(&tup)));
     }
 
     #[test]

foundationdb/src/tuple.rs

@@ -10,6 +10,7 @@
 
 use std;
 use std::io::Write;
+use std::string::FromUtf8Error;
 
 use byteorder::{self, ByteOrder};
 
@@ -38,10 +39,18 @@ pub enum TupleError {
     InvalidType { value: u8 },
     #[fail(display = "Invalid data")]
     InvalidData,
+    #[fail(display = "UTF8 conversion error")]
+    FromUtf8Error(FromUtf8Error),
 }
 
 type Result<T> = std::result::Result<T, TupleError>;
 
+impl From<FromUtf8Error> for TupleError {
+    fn from(error: FromUtf8Error) -> Self {
+        TupleError::FromUtf8Error(error)
+    }
+}
+
 trait SingleType: Copy {
     /// verifies the value matches this type
     fn expect(self, value: u8) -> Result<()>;
@@ -93,7 +102,8 @@ pub trait Single: Sized {
     fn encode_to_vec(&self) -> Vec<u8> {
         let mut v = Vec::new();
         // `self.encode` should not fail because undering `Write` does not return error.
-        self.encode(&mut v).unwrap();
+        self.encode(&mut v)
+            .expect("single encoding should never fail");
         v
     }
 
@@ -215,7 +225,7 @@ impl Single for String {
         STRING.expect(buf[0])?;
 
         let (bytes, offset) = decode_bytes(&buf[1..])?;
-        Ok((String::from_utf8(bytes).unwrap(), offset + 1))
+        Ok((String::from_utf8(bytes)?, offset + 1))
     }
 }
 
@@ -437,7 +447,8 @@ pub trait Tuple: Sized {
     fn encode<W: Write>(&self, _w: &mut W) -> std::io::Result<()>;
     fn encode_to_vec(&self) -> Vec<u8> {
         let mut v = Vec::new();
-        self.encode(&mut v).unwrap();
+        self.encode(&mut v)
+            .expect("tuple encoding should never fail");
         v
     }