chore: serialize for Mask (#5267)

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

Author: blaginin

Cargo.lock

@@ -20,7 +20,7 @@ all-features = true
 arrow = []
 cuda = ["dep:cudarc"]
 memmap2 = ["dep:memmap2"]
-serde = ["dep:serde_core"]
+serde = ["dep:serde"]
 warn-copy = ["dep:log"]
 
 [dependencies]
@@ -32,7 +32,7 @@ itertools = { workspace = true }
 log = { workspace = true, optional = true }
 memmap2 = { workspace = true, optional = true }
 num-traits = { workspace = true }
-serde_core = { workspace = true, optional = true }
+serde = { workspace = true, optional = true }
 simdutf8 = { workspace = true }
 vortex-error = { workspace = true }
 

vortex-buffer/Cargo.toml

@@ -12,6 +12,7 @@ use crate::{Alignment, BitBufferMut, Buffer, BufferMut, ByteBuffer, buffer};
 
 /// An immutable bitset stored as a packed byte buffer.
 #[derive(Debug, Clone, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BitBuffer {
     buffer: ByteBuffer,
     /// Represents the offset of the bit buffer into the first byte.

vortex-buffer/src/bit/buf.rs

@@ -3,8 +3,8 @@
 
 use std::marker::PhantomData;
 
-use serde_core::de::Visitor;
-use serde_core::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::Visitor;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::{Alignment, Buffer, BufferMut, ByteBuffer};
 
@@ -44,31 +44,31 @@ where
 
     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
     where
-        E: serde_core::de::Error,
+        E: serde::de::Error,
     {
         let bytes = ByteBuffer::copy_from_aligned(v, Alignment::of::<T>());
         Ok(Buffer::from_byte_buffer(bytes))
     }
 
     fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
     where
-        E: serde_core::de::Error,
+        E: serde::de::Error,
     {
         let bytes = ByteBuffer::copy_from_aligned(v, Alignment::of::<T>());
         Ok(Buffer::from_byte_buffer(bytes))
     }
 
     fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
     where
-        E: serde_core::de::Error,
+        E: serde::de::Error,
     {
         let bytes = ByteBuffer::copy_from_aligned(v, Alignment::of::<T>());
         Ok(Buffer::from_byte_buffer(bytes))
     }
 
     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
     where
-        A: serde_core::de::SeqAccess<'de>,
+        A: serde::de::SeqAccess<'de>,
     {
         let mut buffer = seq
             .size_hint()

vortex-buffer/src/serde.rs

@@ -56,6 +56,7 @@ serde = [
     "vortex-dtype/serde",
     "vortex-error/serde",
     "vortex-buffer/serde",
+    "vortex-mask/serde",
 ]
 test-harness = []
 

vortex-expr/Cargo.toml

@@ -13,8 +13,12 @@ repository = { workspace = true }
 rust-version = { workspace = true }
 version = { workspace = true }
 
+[features]
+serde = ["dep:serde", "vortex-buffer/serde"]
+
 [dependencies]
 itertools = { workspace = true }
+serde = { workspace = true, optional = true, features = ["rc"] }
 vortex-buffer = { workspace = true, features = ["arrow"] }
 vortex-error = { workspace = true }
 

vortex-mask/Cargo.toml

@@ -98,6 +98,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),
@@ -109,12 +110,15 @@ pub enum Mask {
 
 /// Represents the values of a [`Mask`] that contains some true and some false elements.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MaskValues {
     buffer: BitBuffer,
 
     // We cached the indices and slices representations, since it can be faster than iterating
     // the bit-mask over and over again.
+    #[cfg_attr(feature = "serde", serde(skip))]
     indices: OnceLock<Vec<usize>>,
+    #[cfg_attr(feature = "serde", serde(skip))]
     slices: OnceLock<Vec<(usize, usize)>>,
 
     // Pre-computed values.

vortex-mask/src/lib.rs

@@ -79,6 +79,7 @@ serde = [
     "vortex-expr/serde",
     "vortex-dtype/serde",
     "vortex-buffer/serde",
+    "vortex-mask/serde",
     "vortex-error/serde",
 ]
 # This feature enabled unstable encodings for which we don't guarantee stability.