VarBinVector

Signed-off-by: Nicholas Gates <[email protected]>

Author: gatesn

vortex-vector/src/lib.rs

@@ -17,14 +17,11 @@ mod primitive;
 mod struct_;
 mod varbin;
 
-pub use bool::{BoolVector, BoolVectorMut};
-pub use null::{NullVector, NullVectorMut};
-pub use primitive::{PVector, PVectorMut, PrimitiveVector, PrimitiveVectorMut};
-pub use struct_::{StructVector, StructVectorMut};
-pub use varbin::{
-    BinaryVector, BinaryVectorMut, StringVector, StringVectorMut, VarBinType, VarBinVector,
-    VarBinVectorMut,
-};
+pub use bool::*;
+pub use null::*;
+pub use primitive::*;
+pub use struct_::*;
+pub use varbin::*;
 
 mod ops;
 mod vector;

vortex-vector/src/varbin/mod.rs

@@ -1,16 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
+pub use types::*;
+pub use vector::*;
+pub use vector_mut::*;
+use vortex_error::vortex_panic;
+
 use crate::{Vector, VectorMut};
-use std::fmt::Debug;
 
+mod types;
 mod vector;
-pub use vector::VarBinVector;
-
 mod vector_mut;
-pub use vector_mut::VarBinVectorMut;
-use vortex_error::vortex_panic;
-
 mod view;
 
 /// Type alias for non-utf8 variable-length binary vectors.
@@ -22,81 +22,14 @@ pub type StringVector = VarBinVector<StringType>;
 /// Type alias for mutable UTF-8 variable-length string vectors.
 pub type StringVectorMut = VarBinVectorMut<StringType>;
 
-impl<T: VarBinType> From<VarBinVector<T>> for Vector {
-    fn from(value: VarBinVector<T>) -> Self {
-        T::upcast(value)
-    }
-}
-
-impl<T: VarBinType> From<VarBinVectorMut<T>> for VectorMut {
-    fn from(value: VarBinVectorMut<T>) -> Self {
-        T::upcast(value)
-    }
-}
-
-/// Trait to mark supported binary view types.
-pub trait VarBinType: Debug + Sized + private::Sealed {
-    /// The slice type for this variable binary type.
-    type Slice: ?Sized + AsRef<[u8]>;
-
-    /// Downcast the provided object to a type-specific instance.
-    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self>;
-
-    /// Upcast a type-specific instance to a generic instance.
-    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V;
-}
-
-/// [`BinaryType`] for UTF-8 strings.
-#[derive(Clone, Debug)]
-pub struct StringType;
-impl VarBinType for StringType {
-    type Slice = str;
-
-    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self> {
-        visitor.into_string()
-    }
-
-    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V {
-        V::from_string(input)
-    }
-}
-
-/// [`BinaryType`] for raw binary data.
-#[derive(Clone, Debug)]
-pub struct BinaryType;
-impl VarBinType for BinaryType {
-    type Slice = [u8];
-
-    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self> {
-        visitor.into_binary()
-    }
-
-    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V {
-        V::from_binary(input)
-    }
-}
-
-pub trait VarBinTypeDowncast {
-    type Output<T: VarBinType>;
-
-    fn into_binary(self) -> Self::Output<BinaryType>;
-    fn into_string(self) -> Self::Output<StringType>;
-}
-
-pub trait VarBinTypeUpcast {
-    type Input<T: VarBinType>;
-
-    fn from_binary(input: Self::Input<BinaryType>) -> Self;
-    fn from_string(input: Self::Input<StringType>) -> Self;
-}
-
 impl VarBinTypeDowncast for Vector {
     type Output<T: VarBinType> = VarBinVector<T>;
 
     fn into_binary(self) -> Self::Output<BinaryType> {
         if let Vector::Binary(v) = self {
             return v;
         }
+
         vortex_panic!("Expected BinaryVector, got {self:?}");
     }
 
@@ -149,9 +82,3 @@ impl VarBinTypeUpcast for VectorMut {
         VectorMut::String(input)
     }
 }
-
-mod private {
-    pub trait Sealed {}
-    impl Sealed for super::StringType {}
-    impl Sealed for super::BinaryType {}
-}

vortex-vector/src/varbin/types.rs

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::fmt::Debug;
+
+use crate::{VarBinVector, VarBinVectorMut, Vector, VectorMut};
+
+impl<T: VarBinType> From<VarBinVector<T>> for Vector {
+    fn from(value: VarBinVector<T>) -> Self {
+        T::upcast(value)
+    }
+}
+
+impl<T: VarBinType> From<VarBinVectorMut<T>> for VectorMut {
+    fn from(value: VarBinVectorMut<T>) -> Self {
+        T::upcast(value)
+    }
+}
+
+/// Trait to mark supported binary view types.
+pub trait VarBinType: Debug + Sized + private::Sealed {
+    /// The slice type for this variable binary type.
+    type Slice: ?Sized + AsRef<[u8]>;
+
+    /// Downcast the provided object to a type-specific instance.
+    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self>;
+
+    /// Upcast a type-specific instance to a generic instance.
+    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V;
+}
+
+/// [`BinaryType`] for UTF-8 strings.
+#[derive(Clone, Debug)]
+pub struct StringType;
+impl VarBinType for StringType {
+    type Slice = str;
+
+    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self> {
+        visitor.into_string()
+    }
+
+    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V {
+        V::from_string(input)
+    }
+}
+
+/// [`BinaryType`] for raw binary data.
+#[derive(Clone, Debug)]
+pub struct BinaryType;
+impl VarBinType for BinaryType {
+    type Slice = [u8];
+
+    fn downcast<V: VarBinTypeDowncast>(visitor: V) -> V::Output<Self> {
+        visitor.into_binary()
+    }
+
+    fn upcast<V: VarBinTypeUpcast>(input: V::Input<Self>) -> V {
+        V::from_binary(input)
+    }
+}
+
+/// Trait for downcasting generic variable binary types to specific types.
+pub trait VarBinTypeDowncast {
+    /// The output type after downcasting.
+    type Output<T: VarBinType>;
+
+    /// Downcast to a binary type.
+    fn into_binary(self) -> Self::Output<BinaryType>;
+    /// Downcast to a string type.
+    fn into_string(self) -> Self::Output<StringType>;
+}
+
+/// Trait for upcasting specific variable binary types to generic types.
+pub trait VarBinTypeUpcast {
+    /// The input type for upcasting.
+    type Input<T: VarBinType>;
+
+    /// Upcast from a binary type.
+    fn from_binary(input: Self::Input<BinaryType>) -> Self;
+    /// Upcast from a string type.
+    fn from_string(input: Self::Input<StringType>) -> Self;
+}
+
+mod private {
+    pub trait Sealed {}
+    impl Sealed for super::StringType {}
+    impl Sealed for super::BinaryType {}
+}

vortex-vector/src/varbin/vector.rs

@@ -1,14 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::varbin::vector_mut::VarBinVectorMut;
-use crate::varbin::view::BinaryView;
-use crate::varbin::VarBinType;
-use crate::VectorOps;
 use std::sync::Arc;
+
 use vortex_buffer::{Buffer, ByteBuffer};
 use vortex_mask::Mask;
 
+use crate::VectorOps;
+use crate::varbin::VarBinType;
+use crate::varbin::vector_mut::VarBinVectorMut;
+use crate::varbin::view::BinaryView;
+
 /// A variable-length binary vector.
 #[derive(Debug, Clone)]
 pub struct VarBinVector<T: VarBinType> {

vortex-vector/src/varbin/vector_mut.rs

@@ -1,13 +1,14 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright the Vortex contributors
 
-use crate::varbin::vector::VarBinVector;
-use crate::varbin::view::BinaryView;
-use crate::varbin::VarBinType;
-use crate::VectorMutOps;
 use vortex_buffer::{BufferMut, ByteBuffer};
 use vortex_mask::MaskMut;
 
+use crate::VectorMutOps;
+use crate::varbin::VarBinType;
+use crate::varbin::vector::VarBinVector;
+use crate::varbin::view::BinaryView;
+
 /// Mutable variable-length binary vector.
 #[derive(Clone, Debug)]
 pub struct VarBinVectorMut<T: VarBinType> {