From 233c8e5babbc738065c58d76e860409dff9fa406 Mon Sep 17 00:00:00 2001
From: lsongzhi <lsongzhi@163.com>
Date: Sat, 11 Dec 2021 00:13:56 +0800
Subject: [PATCH] Impl BorrowDecode for Option<&[u8]> and Option<&str>

---
 src/de/impls.rs      | 24 +++++++++++++++++++++++
 tests/basic_types.rs | 45 ++++++++++++++++++++++++++++++++++++++++++++
 tests/derive.rs      |  2 ++
 3 files changed, 71 insertions(+)

diff --git a/src/de/impls.rs b/src/de/impls.rs
index e7d96562..e0f26057 100644
--- a/src/de/impls.rs
+++ b/src/de/impls.rs
@@ -383,6 +383,18 @@ impl<'a, 'de: 'a> BorrowDecode<'de> for &'a [u8] {
     }
 }
 
+impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> {
+    fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+        match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&[u8]>>())? {
+            Some(_) => {
+                let val = BorrowDecode::borrow_decode(decoder)?;
+                Ok(Some(val))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
 impl<'a, 'de: 'a> BorrowDecode<'de> for &'a str {
     fn borrow_decode<D: BorrowDecoder<'de>>(decoder: D) -> Result<Self, DecodeError> {
         let slice: &[u8] = BorrowDecode::borrow_decode(decoder)?;
@@ -390,6 +402,18 @@ impl<'a, 'de: 'a> BorrowDecode<'de> for &'a str {
     }
 }
 
+impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a str> {
+    fn borrow_decode<D: BorrowDecoder<'de>>(mut decoder: D) -> Result<Self, DecodeError> {
+        match super::decode_option_variant(&mut decoder, core::any::type_name::<Option<&str>>())? {
+            Some(_) => {
+                let val = BorrowDecode::borrow_decode(decoder)?;
+                Ok(Some(val))
+            }
+            None => Ok(None),
+        }
+    }
+}
+
 impl<T, const N: usize> Decode for [T; N]
 where
     T: Decode + Sized + 'static,
diff --git a/tests/basic_types.rs b/tests/basic_types.rs
index 8b8d4e8f..da34588f 100644
--- a/tests/basic_types.rs
+++ b/tests/basic_types.rs
@@ -141,6 +141,27 @@ fn test_slice() {
     assert_eq!(input, output);
 }
 
+#[test]
+fn test_option_slice() {
+    let mut buffer = [0u8; 32];
+    let input: Option<&[u8]> = Some(&[1, 2, 3, 4, 5, 6, 7]);
+    let n = bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
+    assert_eq!(&buffer[..n], &[1, 7, 1, 2, 3, 4, 5, 6, 7]);
+
+    let output: Option<&[u8]> =
+        bincode::decode_from_slice(&buffer[..n], Configuration::standard()).unwrap();
+    assert_eq!(input, output);
+
+    let mut buffer = [0u8; 32];
+    let input: Option<&[u8]> = None;
+    let n = bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
+    assert_eq!(&buffer[..n], &[0]);
+
+    let output: Option<&[u8]> =
+        bincode::decode_from_slice(&buffer[..n], Configuration::standard()).unwrap();
+    assert_eq!(input, output);
+}
+
 #[test]
 fn test_str() {
     let mut buffer = [0u8; 32];
@@ -156,6 +177,30 @@ fn test_str() {
     assert_eq!(input, output);
 }
 
+#[test]
+fn test_option_str() {
+    let mut buffer = [0u8; 32];
+    let input: Option<&str> = Some("Hello world");
+    let n = bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
+    assert_eq!(
+        &buffer[..n],
+        &[1, 11, 72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
+    );
+
+    let output: Option<&str> =
+        bincode::decode_from_slice(&buffer[..n], Configuration::standard()).unwrap();
+    assert_eq!(input, output);
+
+    let mut buffer = [0u8; 32];
+    let input: Option<&str> = None;
+    let n = bincode::encode_into_slice(input, &mut buffer, Configuration::standard()).unwrap();
+    assert_eq!(&buffer[..n], &[0]);
+
+    let output: Option<&str> =
+        bincode::decode_from_slice(&buffer[..n], Configuration::standard()).unwrap();
+    assert_eq!(input, output);
+}
+
 #[test]
 fn test_array() {
     let mut buffer = [0u8; 32];
diff --git a/tests/derive.rs b/tests/derive.rs
index 13e52bc9..d1579d33 100644
--- a/tests/derive.rs
+++ b/tests/derive.rs
@@ -22,6 +22,7 @@ pub struct Test3<'a> {
     a: &'a str,
     b: u32,
     c: u32,
+    d: Option<&'a [u8]>,
 }
 
 #[derive(bincode::Encode, bincode::Decode, PartialEq, Debug, Eq)]
@@ -73,6 +74,7 @@ fn test_encode_decode_str() {
         a: "Foo bar",
         b: 10u32,
         c: 1024u32,
+        d: Some(b"Foo bar"),
     };
     let mut slice = [0u8; 100];