WIP: Adding Timestamp decode/encode

Author: junderw

rmp/src/decode/mod.rs

@@ -31,7 +31,7 @@ use std::error;
 
 use num_traits::cast::FromPrimitive;
 
-use crate::Marker;
+use crate::{Marker, Timestamp};
 
 pub mod bytes;
 pub use bytes::Bytes;
@@ -244,6 +244,95 @@ pub fn read_marker<R: RmpRead>(rd: &mut R) -> Result<Marker, MarkerReadError<R::
     Ok(Marker::from_u8(rd.read_u8()?))
 }
 
+/// Attempts to read an Extension struct from the given reader and to decode it as a Timestamp value.
+///
+/// According to the MessagePack specification, there are 3 types of Timestamp, 32, 64, and 96.
+///
+/// # Errors
+///
+/// This function will return `ValueReadError` on any I/O error while reading the Timestamp,
+/// except the EINTR, which is handled internally.
+///
+/// It also returns `ValueReadError::TypeMismatch` if the actual type is not equal with the
+/// expected one, indicating you with the actual type.
+///
+/// # Note
+///
+/// This function will silently retry on every EINTR received from the underlying `Read` until
+/// successful read.
+///
+/// # Examples
+///
+/// ```
+/// use rmp::Timestamp;
+///
+/// // FixExt4 with a type of -1 (0xff)
+/// let mut buf1 = [0xd6, 0xff, 0x66, 0xc1, 0xde, 0x7c];
+/// // FixExt8 with a type of -1 (0xff)
+/// let mut buf2 = [0xd7, 0xff, 0xee, 0x6b, 0x27, 0xfc, 0x66, 0xc1, 0xde, 0x7c];
+/// // Ext8 with a size of 12 (0x0c) and a type of -1 (0xff)
+/// let mut buf3 = [0xc7, 0x0c, 0xff, 0x3b, 0x9a, 0xc9, 0xff, 0x00, 0x00, 0x00, 0x00, 0x66, 0xc1, 0xde, 0x7c];
+///
+/// let ts1_expected = Timestamp::T32 { secs: 0x66c1de7c };
+/// let ts2_expected = Timestamp::T64 { nsecs: 0x3b9ac9ff, secs: 0x66c1de7c };
+/// let ts3_expected = Timestamp::T96 { nsecs: 0x3b9ac9ff, secs: 0x66c1de7c };
+///
+/// let ts1_result = rmp::decode::read_timestamp(&mut buf1.as_slice()).unwrap();
+/// let ts2_result = rmp::decode::read_timestamp(&mut buf2.as_slice()).unwrap();
+/// let ts3_result = rmp::decode::read_timestamp(&mut buf3.as_slice()).unwrap();
+///
+/// assert_eq!(ts1_expected, ts1_result);
+/// assert_eq!(ts2_expected, ts2_result);
+/// assert_eq!(ts3_expected, ts3_result);
+/// ```
+pub fn read_timestamp<R: RmpRead>(rd: &mut R) -> Result<Timestamp, ValueReadError<R::Error>> {
+    let marker = read_marker(rd)?;
+    let prefix = rd.read_data_i8()?;
+    match (marker, prefix) {
+        // timestamp 32
+        (Marker::FixExt4, -1) => {
+            let secs = rd.read_data_u32()? as i64;
+            Ok(Timestamp::T32 {
+                secs,
+            })
+        },
+        // timestamp 64
+        (Marker::FixExt8, -1) => {
+            let data = rd.read_data_u64()?;
+            // 30 bits fits in u32
+            let nsecs = (data >> 34) as u32;
+            if nsecs > 999_999_999 {
+                return Err(ValueReadError::TypeMismatch(Marker::Reserved))
+            }
+            // 34 bits fits in i64
+            let secs = (data & 0x3_ffff_ffff) as i64;
+            Ok(Timestamp::T64 {
+                secs,
+                nsecs,
+            })
+        },
+        // timestamp 96
+        (Marker::Ext8, 12) => {
+            let prefix = rd.read_data_i8()?;
+            if prefix == -1 {
+                let nsecs = rd.read_data_u32()?;
+                if nsecs > 999_999_999 {
+                    return Err(ValueReadError::TypeMismatch(Marker::Reserved))
+                }
+                let secs = rd.read_data_i64()?;
+                Ok(Timestamp::T96 {
+                    secs,
+                    nsecs,
+                })
+            } else {
+                Err(ValueReadError::TypeMismatch(Marker::Reserved))
+            }
+        },
+        (Marker::Ext8 | Marker::FixExt4 | Marker::FixExt8, _) => Err(ValueReadError::TypeMismatch(Marker::Reserved)),
+        (marker, _) => Err(ValueReadError::TypeMismatch(marker)),
+    }
+}
+
 /// Attempts to read a single byte from the given reader and to decode it as a nil value.
 ///
 /// According to the MessagePack specification, a nil value is represented as a single `0xc0` byte.

rmp/src/encode/mod.rs

@@ -19,7 +19,7 @@ use core::fmt::{self, Debug, Display, Formatter};
 #[cfg(feature = "std")]
 use std::error;
 
-use crate::Marker;
+use crate::{Marker, Timestamp};
 
 pub mod buffer;
 pub use buffer::ByteBuf;
@@ -86,6 +86,63 @@ pub fn write_nil<W: RmpWrite>(wr: &mut W) -> Result<(), W::Error> {
     write_marker(wr, Marker::Null).map_err(|e| e.0)
 }
 
+/// Encodes and attempts to write a timestamp value into the given write.
+///
+/// According to the MessagePack specification, a timestamp value is represented as a 32, 64, or 96 bit Extension struct.
+///
+/// # Errors
+///
+/// This function will return `Error` on any I/O error occurred while writing the timestamp.
+///
+/// # Examples
+///
+/// ```
+/// use rmp::Timestamp;
+///
+/// let mut buf1 = Vec::new();
+/// let mut buf2 = Vec::new();
+/// let mut buf3 = Vec::new();
+///
+/// let ts1 = Timestamp::T32 { secs: 0x66c1de7c };
+/// let ts2 = Timestamp::T64 { nsecs: 0x3b9ac9ff, secs: 0x66c1de7c };
+/// let ts3 = Timestamp::T96 { nsecs: 0x3b9ac9ff, secs: 0x66c1de7c };
+///
+/// rmp::encode::write_timestamp(&mut buf1, ts1).ok();
+/// rmp::encode::write_timestamp(&mut buf2, ts2).ok();
+/// rmp::encode::write_timestamp(&mut buf3, ts3).ok();
+///
+/// // FixExt4 with a type of -1 (0xff)
+/// assert_eq!(vec![0xd6, 0xff, 0x66, 0xc1, 0xde, 0x7c], buf1);
+/// // FixExt8 with a type of -1 (0xff)
+/// assert_eq!(vec![0xd7, 0xff, 0xee, 0x6b, 0x27, 0xfc, 0x66, 0xc1, 0xde, 0x7c], buf2);
+/// // Ext8 with a size of 12 (0x0c) and a type of -1 (0xff)
+/// assert_eq!(vec![0xc7, 0x0c, 0xff, 0x3b, 0x9a, 0xc9, 0xff, 0x00, 0x00, 0x00, 0x00, 0x66, 0xc1, 0xde, 0x7c], buf3);
+/// ```
+#[inline]
+pub fn write_timestamp<W: RmpWrite>(wr: &mut W, timestamp: Timestamp) -> Result<(), DataWriteError<W::Error>> {
+    match timestamp {
+        Timestamp::T32 { secs } => {
+            write_marker(wr, Marker::FixExt4).map_err(|e| e.0)?;
+            wr.write_data_i8(-1)?;
+            wr.write_data_u32(secs as u32)?;
+        },
+        Timestamp::T64 { nsecs, secs } => {
+            write_marker(wr, Marker::FixExt8).map_err(|e| e.0)?;
+            let data = ((nsecs as u64) << 34) | (secs as u64);
+            wr.write_data_i8(-1)?;
+            wr.write_data_u64(data)?;
+        },
+        Timestamp::T96 { nsecs, secs } => {
+            write_marker(wr, Marker::Ext8).map_err(|e| e.0)?;
+            wr.write_data_u8(12)?;
+            wr.write_data_i8(-1)?;
+            wr.write_data_u32(nsecs)?;
+            wr.write_data_i64(secs)?;
+        },
+    }
+    Ok(())
+}
+
 /// Encodes and attempts to write a bool value into the given write.
 ///
 /// According to the MessagePack specification, an encoded boolean value is represented as a single

rmp/src/lib.rs

@@ -12,3 +12,19 @@ pub use crate::marker::Marker;
 
 /// Version of the MessagePack [spec](http://github.com/msgpack/msgpack/blob/master/spec.md).
 pub const MSGPACK_VERSION: u32 = 5;
+
+/// A type for holding Timestamp information
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Timestamp {
+    T32 {
+        secs: i64,
+    },
+    T64 {
+        nsecs: u32,
+        secs: i64,
+    },
+    T96 {
+        nsecs: u32,
+        secs: i64,
+    },
+}