add RESP3 new APIs

src/context/call_reply.rs

@@ -37,6 +37,12 @@ impl<'root> Drop for StringCallReply<'root> {
     }
 }
 
+impl<'root> Debug for StringCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.as_bytes())
+    }
+}
+
 pub struct ErrorCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -59,23 +65,18 @@ impl<'root> ErrorCallReply<'root> {
     }
 }
 
-impl<'root> Debug for ErrorCallReply<'root> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "ErrorCallReply: {}.",
-            self.to_string()
-                .unwrap_or("can not transform data into String".to_string())
-        )
-    }
-}
-
 impl<'root> Drop for ErrorCallReply<'root> {
     fn drop(&mut self) {
         free_call_reply(self.reply.as_ptr());
     }
 }
 
+impl<'root> Debug for ErrorCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_string())
+    }
+}
+
 pub struct I64CallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -94,6 +95,12 @@ impl<'root> Drop for I64CallReply<'root> {
     }
 }
 
+impl<'root> Debug for I64CallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_i64())
+    }
+}
+
 pub struct ArrayCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -144,6 +151,13 @@ impl<'root, 'curr> Iterator for ArrayCallReplyIterator<'root, 'curr> {
     }
 }
 
+impl<'root> Debug for ArrayCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let children: Vec<CallResult> = self.iter().collect();
+        write!(f, "{:?}", children)
+    }
+}
+
 pub struct NullCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -155,6 +169,12 @@ impl<'root> Drop for NullCallReply<'root> {
     }
 }
 
+impl<'root> Debug for NullCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Null")
+    }
+}
+
 pub struct MapCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -209,6 +229,13 @@ impl<'root> Drop for MapCallReply<'root> {
     }
 }
 
+impl<'root> Debug for MapCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let elements: Vec<(CallResult, CallResult)> = self.iter().collect();
+        write!(f, "{:?}", elements)
+    }
+}
+
 pub struct SetCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -258,6 +285,13 @@ impl<'root> Drop for SetCallReply<'root> {
     }
 }
 
+impl<'root> Debug for SetCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let elements: Vec<CallResult> = self.iter().collect();
+        write!(f, "{:?}", elements)
+    }
+}
+
 pub struct BoolCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -276,6 +310,12 @@ impl<'root> Drop for BoolCallReply<'root> {
     }
 }
 
+impl<'root> Debug for BoolCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_bool())
+    }
+}
+
 pub struct DoubleCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -294,6 +334,12 @@ impl<'root> Drop for DoubleCallReply<'root> {
     }
 }
 
+impl<'root> Debug for DoubleCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_double())
+    }
+}
+
 pub struct BigNumberCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -313,6 +359,12 @@ impl<'root> Drop for BigNumberCallReply<'root> {
     }
 }
 
+impl<'root> Debug for BigNumberCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_string())
+    }
+}
+
 pub struct VerbatimStringCallReply<'root> {
     reply: NonNull<RedisModuleCallReply>,
     _dummy: PhantomData<&'root ()>,
@@ -355,6 +407,13 @@ impl<'root> Drop for VerbatimStringCallReply<'root> {
     }
 }
 
+impl<'root> Debug for VerbatimStringCallReply<'root> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self.to_parts())
+    }
+}
+
+#[derive(Debug)]
 pub enum CallReply<'root> {
     Unknown,
     I64(I64CallReply<'root>),

src/lib.rs

@@ -28,9 +28,9 @@ pub use crate::context::thread_safe::{DetachedFromClient, ThreadSafeContext};
 #[cfg(feature = "experimental-api")]
 pub use crate::raw::NotifyEvent;
 
-pub use crate::context::call_reply::{CallReply, CallResult};
 pub use crate::configuration::ConfigurationValue;
 pub use crate::configuration::EnumConfigurationValue;
+pub use crate::context::call_reply::{CallReply, CallResult};
 pub use crate::context::keys_cursor::KeysCursor;
 pub use crate::context::server_events;
 pub use crate::context::thread_safe::RedisGILGuard;