add other Filter impls

Signed-off-by: Connor Tsui <connor.tsui20@gmail.com>

Author: connortsui20

vortex-compute/src/filter/buffer.rs

@@ -12,21 +12,48 @@ const FILTER_SLICES_SELECTIVITY_THRESHOLD: f64 = 0.8;
 impl<T: Copy> Filter for &Buffer<T> {
     type Output = Buffer<T>;
 
-    fn filter(self, mask: &Mask) -> Buffer<T> {
-        assert_eq!(mask.len(), self.len());
-        match mask {
+    fn filter(self, selection_mask: &Mask) -> Buffer<T> {
+        assert_eq!(
+            selection_mask.len(),
+            self.len(),
+            "Selection mask length must equal the buffer length"
+        );
+
+        match selection_mask {
             Mask::AllTrue(_) => self.clone(),
             Mask::AllFalse(_) => Buffer::empty(),
             Mask::Values(v) => match v.threshold_iter(FILTER_SLICES_SELECTIVITY_THRESHOLD) {
                 MaskIter::Indices(indices) => filter_indices(self.as_slice(), indices),
                 MaskIter::Slices(slices) => {
-                    filter_slices(self.as_slice(), mask.true_count(), slices)
+                    filter_slices(self.as_slice(), selection_mask.true_count(), slices)
                 }
             },
         }
     }
 }
 
+impl<T: Copy> Filter for Buffer<T> {
+    type Output = Self;
+
+    fn filter(self, selection_mask: &Mask) -> Self {
+        assert_eq!(
+            selection_mask.len(),
+            self.len(),
+            "Selection mask length must equal the buffer length"
+        );
+
+        // If we have exclusive access, we can perform the filter in place.
+        match self.try_into_mut() {
+            Ok(mut buffer_mut) => {
+                (&mut buffer_mut).filter(selection_mask);
+                buffer_mut.freeze()
+            }
+            // Otherwise, allocate a new buffer and fill it in (delegate to the `&Buffer` impl).
+            Err(buffer) => (&buffer).filter(selection_mask),
+        }
+    }
+}
+
 fn filter_indices<T: Copy>(values: &[T], indices: &[usize]) -> Buffer<T> {
     Buffer::<T>::from_trusted_len_iter(indices.iter().map(|&idx| values[idx]))
 }

vortex-compute/src/filter/buffer_mut.rs

@@ -8,8 +8,6 @@ use vortex_mask::Mask;
 
 use crate::filter::Filter;
 
-// TODO(connor): Implement `Filter` for more combinations of `Filter`
-
 impl<T: Copy> Filter for &mut BufferMut<T> {
     type Output = ();
 

vortex-compute/src/filter/mod.rs

@@ -23,5 +23,5 @@ pub trait Filter {
     /// # Panics
     ///
     /// If the length of the mask does not equal the length of the value being filtered.
-    fn filter(self, mask: &Mask) -> Self::Output;
+    fn filter(self, selection_mask: &Mask) -> Self::Output;
 }