split Single and Tuple traits into Encode and Decode

rushmorem · bluejekyll · commit 4b86ae5ab18b · 2018-05-03T12:53:49.000-07:00
Fixes #53
diff --git a/foundationdb/src/bin/bindingtester.rs b/foundationdb/src/bin/bindingtester.rs
@@ -9,7 +9,6 @@ use std::collections::HashMap;
 use fdb::error::FdbError;
 use fdb::keyselector::KeySelector;
 use fdb::tuple::*;
-use fdb::tuple::single::*;
 use fdb::*;
 use futures::future::*;
 use futures::prelude::*;
@@ -177,7 +176,7 @@ impl Instr {
     fn from(data: &[u8]) -> Self {
         use InstrCode::*;
 
-        let tup: tuple::Value = Tuple::decode(data).unwrap();
+        let tup: tuple::Value = tuple::Decode::decode(data).unwrap();
         let cmd = match tup.0[0] {
             single::Value::Str(ref s) => s.clone(),
             _ => panic!("unexpected instr"),
@@ -192,7 +191,7 @@ impl Instr {
 
         let code = match cmd {
             "PUSH" => {
-                let data = Single::encode_to_vec(&tup.0[1]);
+                let data = single::Encode::encode_to_vec(&tup.0[1]);
                 Push(data)
             }
             "DUP" => Dup,
@@ -281,13 +280,13 @@ impl StackItem {
 
         //TODO: wait
         match self.fut.unwrap().wait() {
-            Ok((_trx, data)) => Single::encode_to_vec(&data),
+            Ok((_trx, data)) => single::Encode::encode_to_vec(&data),
             Err(e) => {
                 let code = format!("{}", e.code());
                 let tup = (b"ERROR".to_vec(), code.into_bytes());
                 debug!("ERROR: {:?}", e);
-                let bytes = Tuple::encode_to_vec(&tup);
-                Single::encode_to_vec(&bytes)
+                let bytes = tuple::Encode::encode_to_vec(&tup);
+                single::Encode::encode_to_vec(&bytes)
             }
         }
     }
@@ -380,10 +379,10 @@ impl StackMachine {
 
     fn pop_single<S>(&mut self) -> S
     where
-        S: Single,
+        S: single::Decode,
     {
         let data = self.pop().data();
-        match Single::decode_full(&data) {
+        match single::Decode::decode_full(&data) {
             Ok(v) => v,
             Err(e) => {
                 panic!("failed to decode single {:?}: {:?}", data, e);
@@ -405,9 +404,9 @@ impl StackMachine {
 
     fn push_single<S>(&mut self, number: usize, s: &S)
     where
-        S: Single,
+        S: single::Encode,
     {
-        let data = Single::encode_to_vec(s);
+        let data = single::Encode::encode_to_vec(s);
         self.push(number, data);
     }
 
@@ -601,8 +600,8 @@ impl StackMachine {
                                     continue;
                                 }
                             }
-                            Single::encode(&key.to_vec(), &mut out).expect("failed to encode");
-                            Single::encode(&value.to_vec(), &mut out).expect("failed to encode");
+                            single::Encode::encode(&key.to_vec(), &mut out).expect("failed to encode");
+                            single::Encode::encode(&value.to_vec(), &mut out).expect("failed to encode");
                         }
                         Ok(out)
                     })
@@ -723,8 +722,8 @@ impl StackMachine {
                 let mut data = data.as_slice();
 
                 while !data.is_empty() {
-                    let (val, offset): (single::Value, _) = Single::decode(data).unwrap();
-                    let bytes = Single::encode_to_vec(&val);
+                    let (val, offset): (single::Value, _) = single::Decode::decode(data).unwrap();
+                    let bytes = single::Encode::encode_to_vec(&val);
                     self.push_single(number, &bytes);
                     data = &data[offset..];
                 }
diff --git a/foundationdb/src/subspace.rs b/foundationdb/src/subspace.rs
@@ -15,7 +15,7 @@
 //! general guidance on subspace usage, see the Subspaces section of the Developer Guide
 //! (https://apple.github.io/foundationdb/developer-guide.html#subspaces).
 
-use tuple::{self, Tuple};
+use tuple::{self, Encode, Decode};
 
 /// Subspace represents a well-defined region of keyspace in a FoundationDB database.
 #[derive(Debug, Clone)]
@@ -36,14 +36,14 @@ impl Subspace {
         }
     }
 
-    /// `from_bytes` returns a new Subspace from the provided Tuple.
-    pub fn new<T: Tuple>(t: &T) -> Self {
-        let prefix = Tuple::encode_to_vec(t);
+    /// Returns a new Subspace from the provided tuple encodable.
+    pub fn new<T: Encode>(t: &T) -> Self {
+        let prefix = Encode::encode_to_vec(t);
         Self { prefix }
     }
 
-    /// `subspace` returns a new Subspace whose prefix extends this Subspace with a given tuple.
-    pub fn subspace<T: Tuple>(&self, t: &T) -> Self {
+    /// Returns a new Subspace whose prefix extends this Subspace with a given tuple encodable.
+    pub fn subspace<T: Encode>(&self, t: &T) -> Self {
         Self {
             prefix: self.pack(t),
         }
@@ -54,10 +54,10 @@ impl Subspace {
         self.prefix.as_slice()
     }
 
-    /// `pack` returns the key encoding the specified Tuple with the prefix of this Subspace
+    /// Returns the key encoding the specified Tuple with the prefix of this Subspace
     /// prepended.
-    pub fn pack<T: Tuple>(&self, t: &T) -> Vec<u8> {
-        let mut packed = Tuple::encode_to_vec(t);
+    pub fn pack<T: Encode>(&self, t: &T) -> Vec<u8> {
+        let mut packed = Encode::encode_to_vec(t);
         let mut out = Vec::with_capacity(self.prefix.len() + packed.len());
         out.extend_from_slice(&self.prefix);
         out.append(&mut packed);
@@ -67,12 +67,12 @@ impl Subspace {
     /// `unpack` returns the Tuple encoded by the given key with the prefix of this 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> {
+    pub fn unpack<T: Decode>(&self, key: &[u8]) -> Result<T, tuple::Error> {
         if !self.is_start_of(key) {
-            return Err(TupleError::InvalidData);
+            return Err(tuple::Error::InvalidData);
         }
         let key = &key[self.prefix.len()..];
-        Tuple::decode(&key)
+        Decode::decode(&key)
     }
 
     /// `is_start_of` returns true if the provided key starts with the prefix of this Subspace,
@@ -114,7 +114,7 @@ mod tests {
         let tup = (2, 3);
 
         let packed = ss0.pack(&tup);
-        let expected = Tuple::encode_to_vec(&(1, 2, 3));
+        let expected = Encode::encode_to_vec(&(1, 2, 3));
         assert_eq!(expected, packed);
 
         let tup_unpack: (i64, i64) = ss0.unpack(&packed).unwrap();
diff --git a/foundationdb/src/transaction.rs b/foundationdb/src/transaction.rs
@@ -100,9 +100,9 @@ impl RangeOptionBuilder {
     /// Create new builder with a tuple as a prefix
     pub fn from_tuple<T>(tup: &T) -> Self
     where
-        T: tuple::Tuple,
+        T: tuple::Encode,
     {
-        let bytes = tuple::Tuple::encode_to_vec(tup);
+        let bytes = tuple::Encode::encode_to_vec(tup);
         let mut begin = bytes.clone();
         begin.push(0x00);
 
diff --git a/foundationdb/src/tuple/mod.rs b/foundationdb/src/tuple/mod.rs
@@ -11,7 +11,6 @@
 pub mod single;
 
 use std::{self, io::Write, string::FromUtf8Error};
-use self::single::Single;
 
 #[derive(Debug, Fail)]
 pub enum Error {
@@ -33,24 +32,26 @@ impl From<FromUtf8Error> for Error {
     }
 }
 
-pub trait Tuple: Sized {
+pub trait Encode {
     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)
             .expect("tuple encoding should never fail");
         v
     }
+}
 
+pub trait Decode: Sized {
     fn decode(buf: &[u8]) -> Result<Self>;
 }
 
 macro_rules! tuple_impls {
     ($($len:expr => ($($n:tt $name:ident)+))+) => {
         $(
-            impl<$($name),+> Tuple for ($($name,)+)
+            impl<$($name),+> Encode for ($($name,)+)
             where
-                $($name: Single + Default,)+
+                $($name: single::Encode + Default,)+
             {
                 #[allow(non_snake_case, unused_assignments, deprecated)]
                 fn encode<W: Write>(&self, w: &mut W) -> std::io::Result<()> {
@@ -59,7 +60,12 @@ macro_rules! tuple_impls {
                     )*
                     Ok(())
                 }
+            }
 
+            impl<$($name),+> Decode for ($($name,)+)
+            where
+                $($name: single::Decode + Default,)+
+            {
                 #[allow(non_snake_case, unused_assignments, deprecated)]
                 fn decode(buf: &[u8]) -> Result<Self> {
                     let mut buf = buf;
@@ -99,22 +105,65 @@ tuple_impls! {
 #[derive(Clone, Debug, PartialEq)]
 pub struct Value(pub Vec<single::Value>);
 
-impl Tuple for Value {
+impl Encode for Value {
     fn encode<W: Write>(&self, w: &mut W) -> std::io::Result<()> {
+        use self::single::Encode;
         for item in self.0.iter() {
             item.encode(w)?;
         }
         Ok(())
     }
+}
 
+impl Decode for Value {
     fn decode(buf: &[u8]) -> Result<Self> {
         let mut data = buf;
         let mut v = Vec::new();
         while !data.is_empty() {
-            let (s, offset): (single::Value, _) = Single::decode(data)?;
+            let (s, offset): (single::Value, _) = single::Decode::decode(data)?;
             v.push(s);
             data = &data[offset..];
         }
         Ok(Value(v))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_malformed_int() {
+        assert!(Value::decode(&[21, 0]).is_ok());
+        assert!(Value::decode(&[22, 0]).is_err());
+        assert!(Value::decode(&[22, 0, 0]).is_ok());
+
+        assert!(Value::decode(&[19, 0]).is_ok());
+        assert!(Value::decode(&[18, 0]).is_err());
+        assert!(Value::decode(&[18, 0, 0]).is_ok());
+    }
+
+    #[test]
+    fn test_decode_tuple() {
+        assert_eq!((0, ()), Decode::decode(&[20, 0]).unwrap());
+    }
+
+    #[test]
+    fn test_decode_tuple_ty() {
+        let data: &[u8] = &[2, 104, 101, 108, 108, 111, 0, 1, 119, 111, 114, 108, 100, 0];
+
+        let (v1, v2): (String, Vec<u8>) = Decode::decode(data).unwrap();
+        assert_eq!(v1, "hello");
+        assert_eq!(v2, b"world");
+    }
+
+    #[test]
+    fn test_encode_tuple_ty() {
+        let tup = (String::from("hello"), b"world".to_vec());
+
+        assert_eq!(
+            &[2, 104, 101, 108, 108, 111, 0, 1, 119, 111, 114, 108, 100, 0],
+            Encode::encode_to_vec(&tup).as_slice()
+        );
+    }
+}
diff --git a/foundationdb/src/tuple/single.rs b/foundationdb/src/tuple/single.rs
