feat: impl FromStr for integer types

Author: paolobarbolini

benzina/src/error.rs

@@ -14,3 +14,27 @@ impl Display for TryFromIntError {
 }
 
 impl Error for TryFromIntError {}
+
+#[derive(Debug, Clone)]
+pub enum ParseIntError {
+    Parse(std::num::ParseIntError),
+    OutOfRange(TryFromIntError),
+}
+
+impl Display for ParseIntError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Self::Parse(_err) => "could not parse integer",
+            Self::OutOfRange(_err) => "integer is out of range",
+        })
+    }
+}
+
+impl Error for ParseIntError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::Parse(err) => Some(err),
+            Self::OutOfRange(err) => Some(err),
+        }
+    }
+}

benzina/src/int.rs

@@ -2,6 +2,7 @@ use std::{
     error::Error,
     fmt::{self, Display},
     ptr,
+    str::FromStr,
 };
 
 use diesel::{
@@ -12,7 +13,7 @@ use diesel::{
     sql_types::{BigInt, Integer, SmallInt},
 };
 
-use crate::error::TryFromIntError;
+use crate::error::{ParseIntError, TryFromIntError};
 
 macro_rules! impl_numbers {
     ($($type:ident => $inner:ident, $inner_signed:ident, $sql_type:ident),*) => {
@@ -135,6 +136,17 @@ macro_rules! impl_numbers {
                 }
             }
 
+            impl FromStr for $type {
+                type Err = ParseIntError;
+
+                fn from_str(value: &str) -> Result<Self, Self::Err> {
+                    value
+                        .parse::<$inner>()
+                        .map_err(ParseIntError::Parse)
+                        .and_then(|value| value.try_into().map_err(ParseIntError::OutOfRange))
+                }
+            }
+
             impl Display for $type {
                 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                     Display::fmt(&self.get(), f)