adding impl for core::ops::BitXor

src/bytes.rs

@@ -3,7 +3,7 @@ use crate::buf::IntoIter;
 use crate::debug;
 
 use core::{cmp, fmt, mem, hash, slice, ptr, usize};
-use core::ops::{Deref, DerefMut, RangeBounds};
+use core::ops::{BitXor, Deref, DerefMut, RangeBounds};
 use core::sync::atomic::{self, AtomicUsize, AtomicPtr};
 use core::sync::atomic::Ordering::{Relaxed, Acquire, Release, AcqRel};
 use core::iter::{FromIterator, Iterator};
@@ -2992,6 +2992,24 @@ impl PartialEq<Bytes> for BytesMut
     }
 }
 
+impl BitXor for Bytes {
+    type Output = Option<Self>; //none when rhs length not the same as self length
+
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        if self.len() != rhs.len() { return None; }
+        Some(self.iter().zip(rhs.iter()).map( |(l,r)| *l ^ *r ).collect())
+    }
+}
+
+impl BitXor for BytesMut {
+    type Output = Option<Self>; //none when rhs length not the same as self length
+
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        if self.len() != rhs.len() { return None; }
+        Some(self.iter().zip(rhs.iter()).map( |(l,r)| *l ^ *r ).collect())
+    }
+}
+
 // While there is `std::process:abort`, it's only available in Rust 1.17, and
 // our minimum supported version is currently 1.15. So, this acts as an abort
 // by triggering a double panic, which always aborts in Rust.

tests/test_bytes.rs

@@ -840,6 +840,48 @@ fn from_iter_no_size_hint() {
     assert_eq!(&actual[..], &expect[..]);
 }
 
+#[test]
+fn bytes_mut_xor_success() {
+    let left:&[u8] = &[0x01,0x01,0x00,0x00];
+    let right:&[u8] = &[0x00,0x01,0x00,0x01];
+    let expect:&[u8] = &[0x01,0x00,0x00,0x01];
+    assert_eq!(BytesMut::from(left) ^ BytesMut::from(right), Some(BytesMut::from(expect)));
+    // xor is commutative
+    assert_eq!(BytesMut::from(right) ^ BytesMut::from(left), Some(BytesMut::from(expect)));
+}
+
+#[test]
+fn bytes_mut_xor_zero_lengths_return_zero() {
+    assert_eq!(BytesMut::new() ^ BytesMut::new(), Some(BytesMut::new()));
+}
+
+#[test]
+fn bytes_mut_xor_different_lengths_returns_none() {
+    let left:&[u8] = &[0x01,0x01,0x00,0x00,0x00];
+    let right:&[u8] = &[0x00,0x01,0x00,0x01];
+    assert_eq!(BytesMut::from(left) ^ BytesMut::from(right), None);
+}
+
+#[test]
+fn bytes_xor_success() {
+    let left = &[0x01,0x01,0x00,0x00];
+    let right = &[0x00,0x01,0x00,0x01];
+    let expect = &[0x01,0x00,0x00,0x01];
+    assert_eq!(Bytes::from_static(left) ^ Bytes::from_static(right), Some(Bytes::from_static(expect)));
+    // xor is commutative
+    assert_eq!(Bytes::from_static(right) ^ Bytes::from_static(left), Some(Bytes::from_static(expect)));
+}
+
+#[test]
+fn bytes_xor_zero_lengths_return_zero() {
+    assert_eq!(Bytes::new() ^ Bytes::new(), Some(Bytes::new()));
+}
+
+#[test]
+fn bytes_xor_different_lengths_returns_none() {
+    assert_eq!(Bytes::from_static(&[0x01,0x01,0x00,0x00,0x00]) ^ Bytes::from_static(&[0x00,0x01,0x00,0x01]), None);
+}
+
 fn test_slice_ref(bytes: &Bytes, start: usize, end: usize, expected: &[u8]) {
     let slice = &(bytes.as_ref()[start..end]);
     let sub = bytes.slice_ref(&slice);