Implement From for ByteArray, ByteBuf and Bytes

src/bytearray.rs

@@ -62,6 +62,12 @@ impl<const N: usize> Debug for ByteArray<N> {
     }
 }
 
+impl<const N: usize> Default for ByteArray<N> {
+    fn default() -> Self {
+        ByteArray { bytes: [0; N] }
+    }
+}
+
 impl<const N: usize> AsRef<[u8; N]> for ByteArray<N> {
     fn as_ref(&self) -> &[u8; N] {
         &self.bytes
@@ -112,6 +118,12 @@ impl<const N: usize> BorrowMut<Bytes> for ByteArray<N> {
     }
 }
 
+impl<const N: usize> From<[u8; N]> for ByteArray<N> {
+    fn from(bytes: [u8; N]) -> Self {
+        ByteArray { bytes }
+    }
+}
+
 impl<Rhs, const N: usize> PartialEq<Rhs> for ByteArray<N>
 where
     Rhs: ?Sized + Borrow<[u8; N]>,

src/bytebuf.rs

@@ -131,6 +131,12 @@ impl BorrowMut<Bytes> for ByteBuf {
     }
 }
 
+impl From<Vec<u8>> for ByteBuf {
+    fn from(bytes: Vec<u8>) -> Self {
+        ByteBuf { bytes: bytes }
+    }
+}
+
 impl<Rhs> PartialEq<Rhs> for ByteBuf
 where
     Rhs: ?Sized + AsRef<[u8]>,

src/bytes.rs

@@ -81,6 +81,12 @@ impl DerefMut for Bytes {
     }
 }
 
+impl<'a> From<&'a [u8]> for &'a Bytes {
+    fn from(bytes: &'a [u8]) -> Self {
+        Bytes::new(bytes)
+    }
+}
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl ToOwned for Bytes {
     type Owned = ByteBuf;

tests/test_derive.rs

@@ -138,3 +138,55 @@ fn test() {
         ],
     );
 }
+
+#[derive(Serialize, Deserialize, PartialEq, Debug, Default)]
+struct TestFrom<'a> {
+    #[serde(borrow)]
+    bytes: &'a Bytes,
+    byte_array: ByteArray<4>,
+    byte_buf: ByteBuf,
+}
+
+#[test]
+fn test_from() {
+    let mut test = TestFrom::default();
+
+    assert_tokens(
+        &test,
+        &[
+            Token::Struct {
+                name: "TestFrom",
+                len: 3,
+            },
+            Token::Str("bytes"),
+            Token::BorrowedBytes(b""),
+            Token::Str("byte_array"),
+            Token::Bytes(&[0; 4]),
+            Token::Str("byte_buf"),
+            Token::Bytes(b""),
+            Token::StructEnd,
+        ],
+    );
+
+    let bytes = [255u8; 4];
+    test.byte_array = bytes.into();
+    test.bytes = (&bytes[..]).into();
+    test.byte_buf = bytes.to_vec().into();
+
+    assert_tokens(
+        &test,
+        &[
+            Token::Struct {
+                name: "TestFrom",
+                len: 3,
+            },
+            Token::Str("bytes"),
+            Token::BorrowedBytes(b"\xff\xff\xff\xff"),
+            Token::Str("byte_array"),
+            Token::Bytes(&[255u8; 4]),
+            Token::Str("byte_buf"),
+            Token::Bytes(b"\xff\xff\xff\xff"),
+            Token::StructEnd,
+        ],
+    );
+}