Add conversions module / errors

Add to_u32() helper

Author: maurolacy

packages/std/src/conversion.rs

@@ -0,0 +1,85 @@
+use std::any::type_name;
+use std::convert::TryInto;
+
+use crate::errors::{StdError, StdResult};
+
+pub fn to_u32<T: TryInto<u32> + ToString + Copy>(input: T) -> StdResult<u32> {
+    input.try_into().map_err(|_| {
+        StdError::conversion_err(type_name::<T>(), type_name::<u32>(), input.to_string())
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn to_u32_works_for_usize() {
+        assert_eq!(to_u32(0usize).unwrap(), 0);
+        assert_eq!(to_u32(1usize).unwrap(), 1);
+        assert_eq!(to_u32(2147483647usize).unwrap(), 2147483647);
+        assert_eq!(to_u32(2147483648usize).unwrap(), 2147483648);
+        assert_eq!(to_u32(4294967295usize).unwrap(), 4294967295);
+
+        match to_u32(4294967296usize) {
+            Err(StdError::ConversionErr {
+                from_type,
+                to_type,
+                input,
+                ..
+            }) => {
+                assert_eq!(from_type, "usize");
+                assert_eq!(to_type, "u32");
+                assert_eq!(input, "4294967296");
+            }
+            Err(err) => panic!("unexpected error: {:?}", err),
+            Ok(_) => panic!("must not succeed"),
+        };
+    }
+
+    #[test]
+    fn to_u32_works_for_u64() {
+        assert_eq!(to_u32(0u64).unwrap(), 0);
+        assert_eq!(to_u32(1u64).unwrap(), 1);
+        assert_eq!(to_u32(2147483647u64).unwrap(), 2147483647);
+        assert_eq!(to_u32(2147483648u64).unwrap(), 2147483648);
+        assert_eq!(to_u32(4294967295u64).unwrap(), 4294967295);
+
+        match to_u32(4294967296u64) {
+            Err(StdError::ConversionErr {
+                from_type,
+                to_type,
+                input,
+                ..
+            }) => {
+                assert_eq!(from_type, "u64");
+                assert_eq!(to_type, "u32");
+                assert_eq!(input, "4294967296");
+            }
+            Err(err) => panic!("unexpected error: {:?}", err),
+            Ok(_) => panic!("must not succeed"),
+        };
+    }
+
+    #[test]
+    fn to_u32_works_for_i32() {
+        assert_eq!(to_u32(0i32).unwrap(), 0);
+        assert_eq!(to_u32(1i32).unwrap(), 1);
+        assert_eq!(to_u32(2147483647i32).unwrap(), 2147483647);
+
+        match to_u32(-1i32) {
+            Err(StdError::ConversionErr {
+                from_type,
+                to_type,
+                input,
+                ..
+            }) => {
+                assert_eq!(from_type, "i32");
+                assert_eq!(to_type, "u32");
+                assert_eq!(input, "-1");
+            }
+            Err(err) => panic!("unexpected error: {:?}", err),
+            Ok(_) => panic!("must not succeed"),
+        };
+    }
+}

packages/std/src/errors/std_error.rs

@@ -33,6 +33,14 @@ pub enum StdError {
         #[cfg(feature = "backtraces")]
         backtrace: Backtrace,
     },
+    #[error("Couldn't convert from {} to {}. Input: {}", from_type, to_type, input)]
+    ConversionErr {
+        from_type: String,
+        to_type: String,
+        input: String,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
+    },
     /// Whenever there is no specific error type available
     #[error("Generic error: {msg}")]
     GenericErr {
@@ -108,6 +116,20 @@ impl StdError {
         }
     }
 
+    pub fn conversion_err<S: Into<String>, T: Into<String>, U: Into<String>>(
+        from_type: S,
+        to_type: T,
+        input: U,
+    ) -> Self {
+        StdError::ConversionErr {
+            from_type: from_type.into(),
+            to_type: to_type.into(),
+            input: input.into(),
+            #[cfg(feature = "backtraces")]
+            backtrace: Backtrace::capture(),
+        }
+    }
+
     pub fn generic_err<S: Into<String>>(msg: S) -> Self {
         StdError::GenericErr {
             msg: msg.into(),
@@ -213,6 +235,26 @@ impl PartialEq<StdError> for StdError {
                     false
                 }
             }
+            StdError::ConversionErr {
+                from_type,
+                to_type,
+                input,
+                #[cfg(feature = "backtraces")]
+                    backtrace: _,
+            } => {
+                if let StdError::ConversionErr {
+                    from_type: rhs_from_type,
+                    to_type: rhs_to_type,
+                    input: rhs_input,
+                    #[cfg(feature = "backtraces")]
+                        backtrace: _,
+                } = rhs
+                {
+                    from_type == rhs_from_type && to_type == rhs_to_type && input == rhs_input
+                } else {
+                    false
+                }
+            }
             StdError::GenericErr {
                 msg,
                 #[cfg(feature = "backtraces")]
@@ -414,6 +456,24 @@ mod tests {
         }
     }
 
+    #[test]
+    fn conversion_err_works() {
+        let error = StdError::conversion_err("i32", "u32", "-9");
+        match error {
+            StdError::ConversionErr {
+                from_type,
+                to_type,
+                input,
+                ..
+            } => {
+                assert_eq!(from_type, "i32");
+                assert_eq!(to_type, "u32");
+                assert_eq!(input, "-9");
+            }
+            e => panic!("Unexpected error: {:?}", e),
+        }
+    }
+
     #[test]
     fn invalid_base64_works_for_strings() {
         let error = StdError::invalid_base64("my text");

packages/std/src/lib.rs

@@ -6,6 +6,7 @@
 mod addresses;
 mod binary;
 mod coins;
+mod conversion;
 mod deps;
 mod entry_points;
 mod errors;