MaskValues is serializable

Signed-off-by: blaginin <[email protected]>

Author: blaginin

Cargo.lock

@@ -13,11 +13,18 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+
+[features]
+serde = ["dep:serde"]
+
+
 [dependencies]
 itertools = { workspace = true }
+serde = { workspace = true, optional = true }
 vortex-buffer = { workspace = true, features = ["arrow"] }
 vortex-error = { workspace = true }
 
+
 [dev-dependencies]
 rstest = { workspace = true }
 

vortex-mask/Cargo.toml

@@ -10,6 +10,8 @@ mod intersect_by_rank;
 mod iter_bools;
 mod mask_mut;
 
+#[cfg(feature = "serde")]
+mod serde;
 #[cfg(test)]
 mod tests;
 
@@ -98,6 +100,7 @@ impl<T> Eq for AllOr<T> where T: Eq {}
 /// A [`Mask`] can be constructed from various representations, and converted to various
 /// others. Internally, these are cached.
 #[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(::serde::Serialize, ::serde::Deserialize))]
 pub enum Mask {
     /// All values are included.
     AllTrue(usize),
@@ -123,6 +126,25 @@ pub struct MaskValues {
     density: f64,
 }
 
+impl MaskValues {
+    fn from_buffer(buffer: BitBuffer) -> Self {
+        let count = buffer.true_count();
+        Self::from_buffer_with_counts(buffer, count)
+    }
+
+    fn from_buffer_with_counts(buffer: BitBuffer, true_count: usize) -> Self {
+        let len = buffer.len();
+
+        Self {
+            buffer,
+            indices: Default::default(),
+            slices: Default::default(),
+            true_count,
+            density: true_count as f64 / len as f64,
+        }
+    }
+}
+
 impl Mask {
     /// Create a new Mask where all values are set.
     #[inline]

vortex-mask/src/lib.rs

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use vortex_buffer::BitBuffer;
+
+use crate::MaskValues;
+
+impl Serialize for MaskValues {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.buffer.serialize(serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for MaskValues {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let buffer = BitBuffer::deserialize(deserializer)?;
+        Ok(MaskValues::from_buffer(buffer))
+    }
+}