quicklog(serialize): impl Serialize for primitives, &str

Author: thog92

quicklog/examples/macros.rs

@@ -1,6 +1,6 @@
 use quicklog::{
     debug, error, flush_all, info, init,
-    serialize::{encode_i32, Serialize, Store},
+    serialize::{Serialize, Store},
     trace, warn, with_flush, with_formatter, LogRecord, PatternFormatter,
 };
 use quicklog_flush::stdout_flusher::StdoutFlusher;
@@ -18,7 +18,7 @@ impl std::fmt::Display for S {
 
 impl Serialize for S {
     fn encode<'buf>(&self, write_buf: &'buf mut [u8]) -> Store<'buf> {
-        encode_i32(self.i, write_buf)
+        self.i.encode(write_buf)
     }
 
     fn buffer_size_required(&self) -> usize {

quicklog/src/serialize/mod.rs

@@ -37,50 +37,147 @@ impl Display for Store<'_> {
     }
 }
 
-macro_rules! gen_encode_decode {
-    ($name:ident, $primitive:ty) => {
-        pub fn $name(val: $primitive, write_buf: &mut [u8]) -> Store {
-            assert!(std::mem::size_of::<$primitive>() == write_buf.len());
-
-            fn decode(read_buf: &[u8]) -> String {
-                let x = <$primitive>::from_le_bytes(read_buf.try_into().unwrap());
-                format!("{}", x)
+macro_rules! gen_serialize {
+    ($primitive:ty) => {
+        impl Serialize for $primitive {
+            fn encode<'buf>(&self, write_buf: &'buf mut [u8]) -> Store<'buf> {
+                assert!(std::mem::size_of::<$primitive>() == write_buf.len());
+                fn decode(read_buf: &[u8]) -> String {
+                    let x = <$primitive>::from_le_bytes(read_buf.try_into().unwrap());
+                    format!("{}", x)
+                }
+
+                let size = std::mem::size_of::<$primitive>();
+                let (x, _) = write_buf.split_at_mut(size);
+                x.copy_from_slice(&self.to_le_bytes());
+                Store::new(decode, &*x)
             }
 
-            let size = std::mem::size_of::<$primitive>();
-            let (x, _) = write_buf.split_at_mut(size);
-            x.copy_from_slice(&val.to_le_bytes());
-            Store::new(decode, x)
+            fn buffer_size_required(&self) -> usize {
+                std::mem::size_of::<$primitive>()
+            }
         }
     };
 }
 
-gen_encode_decode!(encode_i32, i32);
-gen_encode_decode!(encode_i64, i64);
-gen_encode_decode!(encode_f32, f32);
-gen_encode_decode!(encode_f64, f64);
-gen_encode_decode!(encode_usize, usize);
+gen_serialize!(i32);
+gen_serialize!(i64);
+gen_serialize!(isize);
+gen_serialize!(f32);
+gen_serialize!(f64);
+gen_serialize!(u32);
+gen_serialize!(u64);
+gen_serialize!(usize);
 
-pub fn encode_str<'buf>(val: &str, write_buf: &'buf mut [u8]) -> Store<'buf> {
-    assert!(val.len() == write_buf.len());
-    fn decode(read_buf: &[u8]) -> String {
-        let x = from_utf8(read_buf).unwrap();
-        x.to_string()
+impl Serialize for &str {
+    fn encode<'buf>(&self, write_buf: &'buf mut [u8]) -> Store<'buf> {
+        assert!(self.len() == write_buf.len());
+        fn decode(read_buf: &[u8]) -> String {
+            let x = from_utf8(read_buf).unwrap();
+            x.to_string()
+        }
+        write_buf.copy_from_slice(self.as_bytes());
+        Store::new(decode, write_buf)
+    }
+
+    fn buffer_size_required(&self) -> usize {
+        self.len()
     }
-    write_buf.copy_from_slice(val.as_bytes());
-    Store::new(decode, write_buf)
 }
 
 /// Eager evaluation into a String for debug structs
 pub fn encode_debug<T: std::fmt::Debug>(val: T, write_buf: &mut [u8]) -> Store {
     let val_string = format!("{:?}", val);
-    assert!(val_string.len() == write_buf.len());
+    // TODO: change back to strict equality when Serialize implemented, to use
+    // `buffer_size_required`
+    assert!(val_string.len() <= write_buf.len());
 
     fn decode(read_buf: &[u8]) -> String {
         let x = from_utf8(read_buf).unwrap();
         x.to_string()
     }
 
-    write_buf.copy_from_slice(val_string.as_bytes());
-    Store::new(decode, write_buf)
+    let (chunk, _) = write_buf.split_at_mut(val_string.len());
+    chunk.copy_from_slice(val_string.as_bytes());
+    Store::new(decode, chunk)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::serialize::encode_debug;
+
+    use super::Serialize;
+
+    macro_rules! assert_primitive_encode_decode {
+        ($primitive:ty, $val:expr) => {{
+            const BUF_SIZE: usize = std::mem::size_of::<$primitive>();
+            let mut buf = [0u8; BUF_SIZE];
+
+            let x: $primitive = $val;
+            let x_store = x.encode(&mut buf);
+            assert_eq!(format!("{}", x), (x_store.decode_fn)(&buf));
+        }};
+    }
+
+    #[test]
+    fn serialize_primitives() {
+        assert_primitive_encode_decode!(i32, -1);
+        assert_primitive_encode_decode!(i64, -123);
+        assert_primitive_encode_decode!(isize, -1234);
+        assert_primitive_encode_decode!(f32, 1.23);
+        assert_primitive_encode_decode!(f64, 1.23456);
+        assert_primitive_encode_decode!(u32, 999);
+        assert_primitive_encode_decode!(u64, 9999);
+        assert_primitive_encode_decode!(usize, 99999);
+    }
+
+    #[test]
+    fn serialize_multiple_primitives() {
+        let mut buf = [0; 128];
+        let a: i32 = -1;
+        let b: u32 = 999;
+        let c: usize = 100000;
+
+        let (a_chunk, chunk) = buf.split_at_mut(a.buffer_size_required());
+        let (b_chunk, chunk) = chunk.split_at_mut(b.buffer_size_required());
+        let (c_chunk, _) = chunk.split_at_mut(c.buffer_size_required());
+
+        let a_store = a.encode(a_chunk);
+        let b_store = b.encode(b_chunk);
+        let c_store = c.encode(c_chunk);
+
+        let a_str = (a_store.decode_fn)(a_store.buffer);
+        let b_str = (b_store.decode_fn)(b_store.buffer);
+        let c_str = (c_store.decode_fn)(c_store.buffer);
+
+        assert_eq!(
+            format!("{} {} {}", a, b, c),
+            format!("{} {} {}", a_str, b_str, c_str)
+        )
+    }
+
+    #[test]
+    fn serialize_str() {
+        let mut buf = [0; 128];
+        let s = "hello world";
+        let (s_chunk, _) = buf.split_at_mut(s.buffer_size_required());
+        let store = s.encode(s_chunk);
+
+        assert_eq!(s, format!("{}", store).as_str())
+    }
+
+    #[test]
+    fn serialize_debug() {
+        #[derive(Debug)]
+        #[allow(unused)]
+        struct DebugStruct {
+            s: &'static str,
+        }
+
+        let mut buf = [0; 128];
+        let s = DebugStruct { s: "Hello World" };
+        let store = encode_debug(&s, &mut buf);
+
+        assert_eq!(format!("{:?}", s), format!("{}", store))
+    }
 }

quicklog/tests/failures/struct_missing_display.stderr

@@ -5,8 +5,15 @@ error[E0277]: the trait bound `Something: Serialize` is not satisfied
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Serialize` is not implemented for `Something`
    |
    = help: the following other types implement trait `Serialize`:
-             SerializeStruct
-             BigStruct
+             isize
+             i32
+             i64
+             usize
+             u32
+             u64
+             f32
+             f64
+           and $N others
 note: required by a bound in `serialize_check`
   --> tests/failures/struct_missing_display.rs:12:5
    |
@@ -31,6 +38,11 @@ error[E0599]: no method named `encode` found for struct `Something` in the curre
    = note: the following trait defines an item `encode`, perhaps you need to implement it:
            candidate #1: `Serialize`
    = note: this error originates in the macro `quicklog::make_store` which comes from the expansion of the macro `info` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: one of the expressions' fields has a method of the same name
+  --> src/macros.rs
+   |
+   |             .some_str.encode($crate::logger().get_chunk_as_mut($serializable.buffer_size_required()))
+   |              +++++++++
 
 error[E0599]: no method named `buffer_size_required` found for struct `Something` in the current scope
   --> tests/failures/struct_missing_display.rs:12:5
@@ -47,3 +59,8 @@ error[E0599]: no method named `buffer_size_required` found for struct `Something
    = note: the following trait defines an item `buffer_size_required`, perhaps you need to implement it:
            candidate #1: `Serialize`
    = note: this error originates in the macro `quicklog::make_store` which comes from the expansion of the macro `info` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: one of the expressions' fields has a method of the same name
+  --> src/macros.rs
+   |
+   |             .encode($crate::logger().get_chunk_as_mut($serializable.some_str.buffer_size_required()))
+   |                                                                     +++++++++