ser/de for f32 using lexical-core

Author: jordens

Cargo.toml

@@ -16,13 +16,18 @@ heapless = "0.5.0"
 
 [dependencies.serde]
 default-features = false
-version = "1.0.80"
+version = "1.0.91"
+
+[dependencies.lexical-core]
+default-features = false
+features = ["ryu"]
+version = "0.4.0"
 
 [dev-dependencies]
-serde_derive = "1.0.80"
+serde_derive = "1.0.91"
 
 [features]
 std = ["serde/std"]
 
 [badges]
-maintenance = { status = "looking-for-maintainer" }
+maintenance = { status = "looking-for-maintainer" }

src/de/mod.rs

@@ -4,6 +4,8 @@ use core::{fmt, str};
 
 use serde::de::{self, Visitor};
 
+use lexical_core::{try_atof32_lossy_slice, ErrorCode};
+
 use self::enum_::UnitVariantAccess;
 use self::map::MapAccess;
 use self::seq::SeqAccess;
@@ -27,6 +29,9 @@ pub enum Error {
     /// EOF while parsing a string.
     EofWhileParsingString,
 
+    /// EOF while parsing a JSON number.
+    EofWhileParsingNumber,
+
     /// EOF while parsing a JSON value.
     EofWhileParsingValue,
 
@@ -360,11 +365,20 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         deserialize_unsigned!(self, visitor, u64, visit_u64)
     }
 
-    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value>
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
+        let r = try_atof32_lossy_slice(&self.slice[self.index..]);
+        match r.error.code {
+            ErrorCode::Success | ErrorCode::InvalidDigit => {
+                self.index += r.error.index;
+                visitor.visit_f32(r.value)
+            },
+            ErrorCode::Empty => Err(Error::EofWhileParsingNumber),
+            _ => Err(Error::InvalidNumber)
+        }
     }
 
     fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
@@ -711,6 +725,46 @@ mod tests {
         assert!(crate::from_str::<Temperature>(r#"{ "temperature": -129 }"#).is_err());
     }
 
+    #[test]
+    fn struct_f32() {
+        #[derive(Debug, Deserialize, PartialEq)]
+        struct Temperature {
+            temperature: f32,
+        }
+
+        assert_eq!(
+            crate::from_str(r#"{ "temperature": -17.2 }"#),
+            Ok(Temperature { temperature: -17.2 })
+        );
+
+        assert_eq!(
+            crate::from_str(r#"{ "temperature": -0.0 }"#),
+            Ok(Temperature { temperature: -0. })
+        );
+
+        assert_eq!(
+            crate::from_str(r#"{ "temperature": -2.1e-3 }"#),
+            Ok(Temperature { temperature: -2.1e-3 })
+        );
+
+        assert_eq!(
+            crate::from_str(r#"{ "temperature": -3 }"#),
+            Ok(Temperature { temperature: -3. })
+        );
+
+        use core::f32;
+
+        assert_eq!(
+            crate::from_str(r#"{ "temperature": -1e500 }"#),
+            Ok(Temperature { temperature: f32::NEG_INFINITY })
+        );
+
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": 1e1e1 }"#).is_err());
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": -2-2 }"#).is_err());
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": 1 1 }"#).is_err());
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": 0.0. }"#).is_err());
+    }
+
     #[test]
     fn struct_option() {
         #[derive(Debug, Deserialize, PartialEq)]

src/ser/mod.rs

@@ -6,6 +6,8 @@ use serde::ser;
 
 use heapless::{String, Vec};
 
+use lexical_core::{f32toa_slice, MAX_F32_SIZE};
+
 use self::seq::SerializeSeq;
 use self::struct_::SerializeStruct;
 
@@ -187,8 +189,10 @@ where
         serialize_unsigned!(self, 20, v)
     }
 
-    fn serialize_f32(self, _v: f32) -> Result<Self::Ok> {
-        unreachable!()
+    fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
+        let mut s: [u8; MAX_F32_SIZE] = [0; MAX_F32_SIZE];
+        self.buf.extend_from_slice(f32toa_slice(v, &mut s))?;
+        Ok(())
     }
 
     fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
@@ -502,6 +506,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn struct_f32() {
+        #[derive(Serialize)]
+        struct Temperature {
+            temperature: f32,
+        }
+
+        assert_eq!(
+            &*crate::to_string::<N, _>(&Temperature { temperature: -20. }).unwrap(),
+            r#"{"temperature":-20.0}"#
+        );
+    }
+
+
     #[test]
     fn struct_option() {
         #[derive(Serialize)]