add f64 ser/de and use macros

Author: jordens

src/de/mod.rs

@@ -277,6 +277,26 @@ 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 = str::from_utf8(&$self.slice[start..$self.index]).unwrap();
+                        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;
 
@@ -369,29 +389,15 @@ impl<'a, 'de> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         self.parse_whitespace().ok_or(Error::EofWhileParsingValue)?;
-        let start = self.index;
-        loop {
-            match self.peek() {
-                Some(b'-') | Some(b'0'..=b'9') | Some(b'.') | Some(b'e') | Some(b'E') => {
-                    self.eat_char();
-                },
-                Some(_) => {
-                    let s = str::from_utf8(&self.slice[start..self.index])
-                        .or(Err(Error::InvalidNumber))?;
-                    let v = f32::from_str(s)
-                        .or(Err(Error::InvalidNumber))?;
-                    return visitor.visit_f32(v);
-                },
-                None => return Err(Error::EofWhileParsingNumber),
-            }
-        }
+        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>

src/ser/mod.rs

@@ -4,7 +4,7 @@ use core::{fmt, fmt::Write};
 
 use serde::ser;
 
-use heapless::{String, Vec};
+use heapless::{String, Vec, consts::*};
 
 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).or(Err(Error::BufferFull))?;
+        $self.buf.extend_from_slice(s.as_bytes())?;
+        Ok(())
+    }};
+}
+
 impl<'a, B> ser::Serializer for &'a mut Serializer<B>
 where
     B: heapless::ArrayLength<u8>,
@@ -188,14 +197,11 @@ where
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
-        let mut s: String<heapless::consts::U32> = String::new();
-        write!(&mut s, "{:e}", v).unwrap();
-        self.buf.extend_from_slice(s.as_bytes())?;
-        Ok(())
+        serialize_fmt!(self, U32, "{:e}", v)
     }
 
-    fn serialize_f64(self, _v: f64) -> Result<Self::Ok> {
-        unreachable!()
+    fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
+        serialize_fmt!(self, U64, "{:e}", v)
     }
 
     fn serialize_char(self, _v: char) -> Result<Self::Ok> {