Introduce custom Bytes type

Instead of relying on `Cow<'_, [u8]>`. It makes the code easier to
read but also allows us to implement the various traits we need
the way we want them to. And it also makes experimenting with
different represention more easier.

Author: marmeladema

engine/benches/bench.rs

@@ -6,9 +6,9 @@ use std::alloc::System;
 static A: System = System;
 
 use criterion::{Bencher, Criterion, criterion_group, criterion_main};
-use std::{borrow::Cow, clone::Clone, fmt::Debug, net::IpAddr};
+use std::{clone::Clone, fmt::Debug, net::IpAddr};
 use wirefilter::{
-    ExecutionContext, FilterAst, FunctionArgs, GetType, LhsValue, SchemeBuilder,
+    Bytes, ExecutionContext, FilterAst, FunctionArgs, GetType, LhsValue, SchemeBuilder,
     SimpleFunctionArgKind, SimpleFunctionDefinition, SimpleFunctionImpl, SimpleFunctionParam, Type,
 };
 
@@ -17,7 +17,7 @@ fn lowercase<'a>(args: FunctionArgs<'_, 'a>) -> Option<LhsValue<'a>> {
     match input {
         LhsValue::Bytes(mut bytes) => {
             let make_lowercase = match bytes {
-                Cow::Borrowed(bytes) => bytes.iter().any(u8::is_ascii_uppercase),
+                Bytes::Borrowed(bytes) => bytes.iter().any(u8::is_ascii_uppercase),
                 _ => true,
             };
             if make_lowercase {
@@ -34,7 +34,7 @@ fn uppercase<'a>(args: FunctionArgs<'_, 'a>) -> Option<LhsValue<'a>> {
     match input {
         LhsValue::Bytes(mut bytes) => {
             let make_uppercase = match bytes {
-                Cow::Borrowed(bytes) => bytes.iter().any(u8::is_ascii_lowercase),
+                Bytes::Borrowed(bytes) => bytes.iter().any(u8::is_ascii_lowercase),
                 _ => true,
             };
             if make_uppercase {

engine/src/ast/function_expr.rs

@@ -562,13 +562,10 @@ mod tests {
     }
 
     fn lower_function<'a>(args: FunctionArgs<'_, 'a>) -> Option<LhsValue<'a>> {
-        use std::borrow::Cow;
-
         match args.next()? {
             Ok(LhsValue::Bytes(mut b)) => {
-                let mut text: Vec<u8> = b.to_mut().to_vec();
-                text.make_ascii_lowercase();
-                Some(LhsValue::Bytes(Cow::Owned(text)))
+                b.to_mut().make_ascii_lowercase();
+                Some(LhsValue::Bytes(b))
             }
             Err(Type::Bytes) => None,
             _ => unreachable!(),

engine/src/functions/concat.rs

@@ -1,8 +1,8 @@
 use crate::{
-    Array, ExpectedType, FunctionArgs, FunctionDefinition, FunctionDefinitionContext,
+    Array, Bytes, ExpectedType, FunctionArgs, FunctionDefinition, FunctionDefinitionContext,
     FunctionParam, FunctionParamError, GetType, LhsValue, ParserSettings, Type,
 };
-use std::{borrow::Cow, iter::once};
+use std::iter::once;
 
 /// A function which, given one or more arrays or byte-strings, returns the
 /// concatenation of each of them.
@@ -43,15 +43,15 @@ fn concat_array<'a>(accumulator: Array<'a>, args: FunctionArgs<'_, 'a>) -> Array
     Array::try_from_vec(val_type, vec).unwrap()
 }
 
-fn concat_bytes<'a>(mut accumulator: Cow<'a, [u8]>, args: FunctionArgs<'_, 'a>) -> Cow<'a, [u8]> {
+fn concat_bytes<'a>(mut accumulator: Vec<u8>, args: FunctionArgs<'_, 'a>) -> Bytes<'a> {
     for arg in args {
         match arg {
-            Ok(LhsValue::Bytes(value)) => accumulator.to_mut().extend(value.iter()),
+            Ok(LhsValue::Bytes(value)) => accumulator.extend_from_slice(&value),
             Err(Type::Bytes) => (),
             _ => (),
         }
     }
-    accumulator
+    accumulator.into()
 }
 
 pub(crate) const EXPECTED_TYPES: [ExpectedType; 2] =
@@ -103,7 +103,10 @@ impl FunctionDefinition for ConcatFunction {
                         return Some(LhsValue::Array(concat_array(array, args)));
                     }
                     Ok(LhsValue::Bytes(bytes)) => {
-                        return Some(LhsValue::Bytes(concat_bytes(bytes, args)));
+                        return Some(LhsValue::Bytes(concat_bytes(
+                            bytes.into_owned().into(),
+                            args,
+                        )));
                     }
                     Err(_) => (),
                     _ => unreachable!(),
@@ -124,27 +127,27 @@ mod tests {
     #[test]
     fn test_concat_bytes() {
         let mut args = vec![
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"hello"))),
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"world"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"hello"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"world"))),
         ]
         .into_iter();
         assert_eq!(
-            Some(LhsValue::Bytes(Cow::Borrowed(b"helloworld"))),
+            Some(LhsValue::Bytes(Bytes::Borrowed(b"helloworld"))),
             CONCAT_FN.compile(&mut std::iter::empty(), None)(&mut args)
         );
     }
 
     #[test]
     fn test_concat_many_bytes() {
         let mut args = vec![
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"hello"))),
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"world"))),
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"hello2"))),
-            Ok(LhsValue::Bytes(Cow::Borrowed(b"world2"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"hello"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"world"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"hello2"))),
+            Ok(LhsValue::Bytes(Bytes::Borrowed(b"world2"))),
         ]
         .into_iter();
         assert_eq!(
-            Some(LhsValue::Bytes(Cow::Borrowed(b"helloworldhello2world2"))),
+            Some(LhsValue::Bytes(Bytes::Borrowed(b"helloworldhello2world2"))),
             CONCAT_FN.compile(&mut std::iter::empty(), None)(&mut args)
         );
     }