few api improvements:

- bump num-bigint to 0.3.0
- define Element ordering

Author: Speedy37

foundationdb-bindingtester/Cargo.toml

@@ -25,5 +25,5 @@ foundationdb = { path = "../foundationdb", features = ["uuid", "num-bigint"] }
 foundationdb-sys = { version = "0.5.0", path = "../foundationdb-sys", default-features = false }
 futures = "0.3.0"
 log = "0.4.8"
-num-bigint = "0.2.6"
+num-bigint = "0.3.0"
 structopt = "0.3.3"

foundationdb/Cargo.toml

@@ -45,7 +45,7 @@ memchr = "2.2.1"
 rand = "0.7.2"
 static_assertions = "1.1.0"
 uuid = { version = "0.8.1", optional = true }
-num-bigint = { version = "0.2.6", optional = true }
+num-bigint = { version = "0.3.0", optional = true }
 
 [dev-dependencies]
 byteorder = "1.3.2"

foundationdb/src/tuple/element.rs

@@ -1,73 +1,217 @@
+use super::pack::{f32_to_u32_be_bytes, f64_to_u64_be_bytes};
 use super::{Bytes, Versionstamp};
-use std::borrow::Cow;
+use std::{borrow::Cow, cmp};
 
-#[derive(Clone, PartialEq, Debug)]
+#[cfg(feature = "num-bigint")]
+use std::convert::TryInto;
+
+#[derive(Clone, Debug)]
 pub enum Element<'a> {
     Nil,
     Bytes(Bytes<'a>),
     String(Cow<'a, str>),
     Tuple(Vec<Element<'a>>),
     Int(i64),
+    #[cfg(feature = "num-bigint")]
+    BigInt(num_bigint::BigInt),
     Float(f32),
     Double(f64),
     Bool(bool),
-    Versionstamp(Versionstamp),
     #[cfg(feature = "uuid")]
     Uuid(uuid::Uuid),
-    #[cfg(feature = "num-bigint")]
-    BigInt(num_bigint::BigInt),
+    Versionstamp(Versionstamp),
+}
+
+struct CmpElement<'a, 'b>(&'a Element<'b>);
+
+impl<'a, 'b> PartialEq for CmpElement<'a, 'b> {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == cmp::Ordering::Equal
+    }
+}
+impl<'a, 'b> Eq for CmpElement<'a, 'b> {}
+
+impl<'a, 'b> PartialOrd for CmpElement<'a, 'b> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<'a, 'b> Ord for CmpElement<'a, 'b> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.0
+            .code()
+            .cmp(&other.0.code())
+            .then_with(|| match (&self.0, &other.0) {
+                (Element::Bytes(a), Element::Bytes(b)) => a.cmp(b),
+                (Element::String(a), Element::String(b)) => a.cmp(b),
+                (Element::Tuple(a), Element::Tuple(b)) => {
+                    let a_values = a.iter().map(CmpElement);
+                    let b_values = b.iter().map(CmpElement);
+                    a_values.cmp(b_values)
+                }
+                (Element::Int(a), Element::Int(b)) => a.cmp(b),
+                #[cfg(feature = "num-bigint")]
+                (Element::BigInt(a), Element::BigInt(b)) => a.cmp(b),
+                (Element::Float(a), Element::Float(b)) => {
+                    f32_to_u32_be_bytes(*a).cmp(&f32_to_u32_be_bytes(*b))
+                }
+                (Element::Double(a), Element::Double(b)) => {
+                    f64_to_u64_be_bytes(*a).cmp(&f64_to_u64_be_bytes(*b))
+                }
+                #[cfg(feature = "uuid")]
+                (Element::Uuid(a), Element::Uuid(b)) => a.cmp(b),
+                (Element::Versionstamp(a), Element::Versionstamp(b)) => a.cmp(b),
+                _ => cmp::Ordering::Equal,
+            })
+    }
+}
+
+impl<'a> PartialEq for Element<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other) == cmp::Ordering::Equal
+    }
+}
+impl<'a> Eq for Element<'a> {}
+
+impl<'a> PartialOrd for Element<'a> {
+    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+impl<'a> Ord for Element<'a> {
+    fn cmp(&self, other: &Self) -> cmp::Ordering {
+        self.cmp_at_root(other)
+    }
 }
 
 impl<'a> Element<'a> {
+    fn code(&self) -> u8 {
+        match self {
+            Element::Nil => super::NIL,
+            Element::Bytes(_) => super::BYTES,
+            Element::String(_) => super::STRING,
+            Element::Tuple(_) => super::NESTED,
+            Element::Int(_) => super::INTZERO,
+            #[cfg(feature = "num-bigint")]
+            Element::BigInt(_) => super::POSINTEND,
+            Element::Float(_) => super::FLOAT,
+            Element::Double(_) => super::DOUBLE,
+            Element::Bool(v) => {
+                if *v {
+                    super::TRUE
+                } else {
+                    super::FALSE
+                }
+            }
+            #[cfg(feature = "uuid")]
+            Element::Uuid(_) => super::UUID,
+            Element::Versionstamp(_) => super::VERSIONSTAMP,
+        }
+    }
+
+    #[inline]
+    fn cmp_values(&self) -> &[Self] {
+        match self {
+            Element::Tuple(v) => v.as_slice(),
+            v => std::slice::from_ref(v),
+        }
+    }
+
+    fn cmp_at_root<'b>(&self, b: &Element<'b>) -> cmp::Ordering {
+        let a_values = self.cmp_values().iter().map(CmpElement);
+        let b_values = b.cmp_values().iter().map(CmpElement);
+        a_values.cmp(b_values)
+    }
+
     pub fn into_owned(self) -> Element<'static> {
         match self {
             Element::Nil => Element::Nil,
-            Element::Bool(v) => Element::Bool(v),
+            Element::Bytes(v) => Element::Bytes(v.into_owned().into()),
+            Element::String(v) => Element::String(Cow::Owned(v.into_owned())),
+            Element::Tuple(v) => Element::Tuple(v.into_iter().map(|e| e.into_owned()).collect()),
             Element::Int(v) => Element::Int(v),
+            #[cfg(feature = "num-bigint")]
+            Element::BigInt(v) => Element::BigInt(v),
             Element::Float(v) => Element::Float(v),
             Element::Double(v) => Element::Double(v),
-            Element::String(v) => Element::String(Cow::Owned(v.into_owned())),
-            Element::Bytes(v) => Element::Bytes(v.into_owned().into()),
-            Element::Versionstamp(v) => Element::Versionstamp(v),
-            Element::Tuple(v) => Element::Tuple(v.into_iter().map(|e| e.into_owned()).collect()),
+            Element::Bool(v) => Element::Bool(v),
             #[cfg(feature = "uuid")]
             Element::Uuid(v) => Element::Uuid(v),
-            #[cfg(feature = "num-bigint")]
-            Element::BigInt(v) => Element::BigInt(v),
+            Element::Versionstamp(v) => Element::Versionstamp(v),
         }
     }
 
-    pub fn as_bool(&self) -> Option<bool> {
-        match *self {
-            Element::Bool(v) => Some(v),
+    pub fn as_bytes(&self) -> Option<&Bytes> {
+        match self {
+            Element::Bytes(v) => Some(v),
+            _ => None,
+        }
+    }
+
+    pub fn as_str(&self) -> Option<&str> {
+        match self {
+            Element::String(v) => Some(&v),
+            _ => None,
+        }
+    }
+
+    pub fn as_tuple(&self) -> Option<&[Element<'a>]> {
+        match self {
+            Element::Tuple(v) => Some(v.as_slice()),
             _ => None,
         }
     }
 
     pub fn as_i64(&self) -> Option<i64> {
-        match *self {
-            Element::Int(v) => Some(v),
+        match self {
+            Element::Int(v) => Some(*v),
+            #[cfg(feature = "num-bigint")]
+            Element::BigInt(v) => v.try_into().ok(),
             _ => None,
         }
     }
 
-    pub fn as_str(&self) -> Option<&str> {
+    #[cfg(feature = "num-bigint")]
+    pub fn as_bigint(&self) -> Option<&num_bigint::BigInt> {
         match self {
-            Element::String(v) => Some(&v),
+            Element::BigInt(v) => Some(v),
             _ => None,
         }
     }
 
-    pub fn as_bytes(&self) -> Option<&Bytes> {
+    pub fn as_f32(&self) -> Option<f32> {
         match self {
-            Element::Bytes(v) => Some(v),
+            Element::Float(v) => Some(*v),
             _ => None,
         }
     }
 
-    pub fn as_tuple(&self) -> Option<&[Element<'a>]> {
+    pub fn as_f64(&self) -> Option<f64> {
         match self {
-            Element::Tuple(v) => Some(v.as_slice()),
+            Element::Double(v) => Some(*v),
+            _ => None,
+        }
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        match *self {
+            Element::Bool(v) => Some(v),
+            _ => None,
+        }
+    }
+
+    #[cfg(feature = "uuid")]
+    pub fn as_uuid(&self) -> Option<&uuid::Uuid> {
+        match self {
+            Element::Uuid(v) => Some(v),
+            _ => None,
+        }
+    }
+
+    pub fn as_versionstamp(&self) -> Option<&Versionstamp> {
+        match self {
+            Element::Versionstamp(v) => Some(v),
             _ => None,
         }
     }

foundationdb/src/tuple/pack.rs

@@ -450,21 +450,25 @@ macro_rules! impl_ix {
 }
 
 macro_rules! impl_fx {
-    ( $fx: ident, $parse_ux: ident, $ux: ident, $code: ident) => {
+    ( $fx: ident, $fx_to_ux_be_bytes: ident, $ux_width: tt, $parse_ux: ident, $ux: ident, $code: ident) => {
+        #[inline]
+        pub(super) fn $fx_to_ux_be_bytes(f: $fx) -> [u8; $ux_width] {
+            let u = if f.is_sign_negative() {
+                f.to_bits() ^ ::std::$ux::MAX
+            } else {
+                f.to_bits() ^ sign_bit!($ux)
+            };
+            u.to_be_bytes()
+        }
         impl TuplePack for $fx {
             fn pack<W: io::Write>(
                 &self,
                 w: &mut W,
                 _tuple_depth: TupleDepth,
             ) -> io::Result<VersionstampOffset> {
-                let f = *self;
-                let u = if f.is_sign_negative() {
-                    f.to_bits() ^ ::std::$ux::MAX
-                } else {
-                    f.to_bits() ^ sign_bit!($ux)
-                };
+                let bytes = $fx_to_ux_be_bytes(*self);
                 w.write_all(&[$code])?;
-                w.write_all(&u.to_be_bytes())?;
+                w.write_all(&bytes)?;
                 Ok(VersionstampOffset::None {
                     size: std::mem::size_of::<$fx>() as u32 / 8 + 1,
                 })
@@ -508,8 +512,8 @@ impl_ix!(i64, u64);
 impl_ix!(i128, u128, MAX_SZ);
 impl_ix!(isize, usize);
 
-impl_fx!(f32, parse_u32, u32, FLOAT);
-impl_fx!(f64, parse_u64, u64, DOUBLE);
+impl_fx!(f32, f32_to_u32_be_bytes, 4, parse_u32, u32, FLOAT);
+impl_fx!(f64, f64_to_u64_be_bytes, 8, parse_u64, u64, DOUBLE);
 
 #[cfg(feature = "num-bigint")]
 mod bigint {