Merge #21

21: rebased PR #12 r=japaric a=japaric

closes #12

Co-authored-by: Robert Jördens <rj@quartiq.de>
Co-authored-by: Jorge Aparicio <jorge@japaric.io>

Author: 3 people

Cargo.toml

@@ -25,4 +25,4 @@ serde_derive = "1.0.80"
 std = ["serde/std"]
 
 [badges]
-maintenance = { status = "looking-for-maintainer" }
+maintenance = { status = "looking-for-maintainer" }

src/de/mod.rs

@@ -1,5 +1,6 @@
 //! Deserialize JSON data to a Rust data structure
 
+use core::str::FromStr;
 use core::{fmt, str};
 
 use serde::de::{self, Visitor};
@@ -27,6 +28,9 @@ pub enum Error {
     /// EOF while parsing a string.
     EofWhileParsingString,
 
+    /// EOF while parsing a JSON number.
+    EofWhileParsingNumber,
+
     /// EOF while parsing a JSON value.
     EofWhileParsingValue,
 
@@ -273,6 +277,29 @@ macro_rules! deserialize_signed {
     }};
 }
 
+macro_rules! deserialize_fromstr {
+    ($self:ident, $visitor:ident, $typ:ident, $visit_fn:ident, $pattern:expr) => {{
+        let start = $self.index;
+        loop {
+            match $self.peek() {
+                Some(c) => {
+                    if $pattern.iter().find(|&&d| d == c).is_some() {
+                        $self.eat_char();
+                    } else {
+                        let s = unsafe {
+                            // already checked that it contains only ascii
+                            str::from_utf8_unchecked(&$self.slice[start..$self.index])
+                        };
+                        let v = $typ::from_str(s).or(Err(Error::InvalidNumber))?;
+                        return $visitor.$visit_fn(v);
+                    }
+                }
+                None => return Err(Error::EofWhileParsingNumber),
+            }
+        }
+    }};
+}
+
 impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     type Error = Error;
 
@@ -360,18 +387,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)?;
+        deserialize_fromstr!(self, visitor, f32, visit_f32, b"0123456789+-.eE")
     }
 
-    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value>
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
     where
         V: Visitor<'de>,
     {
-        unreachable!()
+        self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
+        deserialize_fromstr!(self, visitor, f64, visit_f64, b"0123456789+-.eE")
     }
 
     fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
@@ -711,6 +740,51 @@ 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());
+        assert!(crate::from_str::<Temperature>(r#"{ "temperature": ä }"#).is_err());
+    }
+
     #[test]
     fn struct_option() {
         #[derive(Debug, Deserialize, PartialEq)]

src/ser/mod.rs

@@ -1,10 +1,10 @@
 //! Serialize a Rust data structure into JSON data
 
-use core::fmt;
+use core::{fmt, fmt::Write};
 
 use serde::ser;
 
-use heapless::{String, Vec};
+use heapless::{consts::*, String, Vec};
 
 use self::seq::SerializeSeq;
 use self::struct_::SerializeStruct;
@@ -123,6 +123,15 @@ macro_rules! serialize_signed {
     }};
 }
 
+macro_rules! serialize_fmt {
+    ($self:ident, $uxx:ident, $fmt:expr, $v:expr) => {{
+        let mut s: String<$uxx> = String::new();
+        write!(&mut s, $fmt, $v).unwrap();
+        $self.buf.extend_from_slice(s.as_bytes())?;
+        Ok(())
+    }};
+}
+
 impl<'a, B> ser::Serializer for &'a mut Serializer<B>
 where
     B: heapless::ArrayLength<u8>,
@@ -187,12 +196,12 @@ 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> {
+        serialize_fmt!(self, U16, "{:e}", v)
     }
 
-    fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
-        unreachable!()
+    fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
+        serialize_fmt!(self, U32, "{:e}", v)
     }
 
     fn serialize_char(self, _v: char) -> Result<Self::Ok> {
@@ -502,6 +511,35 @@ mod tests {
         );
     }
 
+    #[test]
+    fn struct_f32() {
+        #[derive(Serialize)]
+        struct Temperature {
+            temperature: f32,
+        }
+
+        assert_eq!(
+            &*crate::to_string::<N, _>(&Temperature { temperature: -20. }).unwrap(),
+            r#"{"temperature":-2e1}"#
+        );
+
+        assert_eq!(
+            &*crate::to_string::<N, _>(&Temperature {
+                temperature: -20345.
+            })
+            .unwrap(),
+            r#"{"temperature":-2.0345e4}"#
+        );
+
+        assert_eq!(
+            &*crate::to_string::<N, _>(&Temperature {
+                temperature: -2.3456789012345e-23
+            })
+            .unwrap(),
+            r#"{"temperature":-2.3456788e-23}"#
+        );
+    }
+
     #[test]
     fn struct_option() {
         #[derive(Serialize)]