Trait ChunkComponentSlicer

pub trait ChunkComponentSlicer {
    type Item<'a>;

    // Required method
    fn slice<'a>(
        component_name: ComponentName,
        array: &'a dyn Array,
        component_offsets: impl Iterator<Item = (usize, usize)> + 'a,
    ) -> impl Iterator<Item = Self::Item<'a>> + 'a;
}

A ChunkComponentSlicer knows how to efficiently slice component batches out of a Chunk column.

See Chunk::iter_slices and Chunk::iter_slices_from_struct_field.

Required Associated Types

type Item<'a>

Required Methods

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = Self::Item<'a>> + 'a

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl ChunkComponentSlicer for &[f32]

type Item<'a> = Vec<ScalarBuffer<f32>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[f32] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[f64]

type Item<'a> = Vec<ScalarBuffer<f64>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[f64] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i8]

type Item<'a> = Vec<ScalarBuffer<i8>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[i8] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i16]

type Item<'a> = Vec<ScalarBuffer<i16>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[i16] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i32]

type Item<'a> = Vec<ScalarBuffer<i32>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[i32] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[i64]

type Item<'a> = Vec<ScalarBuffer<i64>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[i64] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u8]

type Item<'a> = Vec<ScalarBuffer<u8>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[u8] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u16]

type Item<'a> = Vec<ScalarBuffer<u16>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[u16] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u32]

type Item<'a> = Vec<ScalarBuffer<u32>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[u32] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[u64]

type Item<'a> = Vec<ScalarBuffer<u64>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[u64] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for &[f16]

type Item<'a> = Vec<ScalarBuffer<f16>>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[f16] as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for bool

type Item<'a> = BooleanBuffer

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <bool as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for f32

type Item<'a> = &'a [f32]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <f32 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for f64

type Item<'a> = &'a [f64]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <f64 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for i8

type Item<'a> = &'a [i8]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <i8 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for i16

type Item<'a> = &'a [i16]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <i16 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for i32

type Item<'a> = &'a [i32]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <i32 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for i64

type Item<'a> = &'a [i64]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <i64 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for u8

type Item<'a> = &'a [u8]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <u8 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for u16

type Item<'a> = &'a [u16]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <u16 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for u32

type Item<'a> = &'a [u32]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <u32 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for u64

type Item<'a> = &'a [u64]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <u64 as ChunkComponentSlicer>::Item<'a>> + 'a

impl ChunkComponentSlicer for String

type Item<'a> = Vec<ArrowString>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = Vec<ArrowString>> + 'a

impl ChunkComponentSlicer for f16

type Item<'a> = &'a [f16]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <f16 as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f32; N]]

where [f32; N]: Pod,

type Item<'a> = Vec<&'a [[f32; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[f32; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f64; N]]

where [f64; N]: Pod,

type Item<'a> = Vec<&'a [[f64; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[f64; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i8; N]]

where [i8; N]: Pod,

type Item<'a> = Vec<&'a [[i8; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[i8; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i16; N]]

where [i16; N]: Pod,

type Item<'a> = Vec<&'a [[i16; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[i16; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i32; N]]

where [i32; N]: Pod,

type Item<'a> = Vec<&'a [[i32; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[i32; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[i64; N]]

where [i64; N]: Pod,

type Item<'a> = Vec<&'a [[i64; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[i64; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u8; N]]

where [u8; N]: Pod,

type Item<'a> = Vec<&'a [[u8; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[u8; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u16; N]]

where [u16; N]: Pod,

type Item<'a> = Vec<&'a [[u16; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[u16; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u32; N]]

where [u32; N]: Pod,

type Item<'a> = Vec<&'a [[u32; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[u32; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[u64; N]]

where [u64; N]: Pod,

type Item<'a> = Vec<&'a [[u64; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[u64; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for &[[f16; N]]

where [f16; N]: Pod,

type Item<'a> = Vec<&'a [[f16; N]]>

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <&[[f16; N]] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f32; N]

where [f32; N]: Pod,

type Item<'a> = &'a [[f32; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[f32; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f64; N]

where [f64; N]: Pod,

type Item<'a> = &'a [[f64; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[f64; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i8; N]

where [i8; N]: Pod,

type Item<'a> = &'a [[i8; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[i8; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i16; N]

where [i16; N]: Pod,

type Item<'a> = &'a [[i16; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[i16; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i32; N]

where [i32; N]: Pod,

type Item<'a> = &'a [[i32; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[i32; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [i64; N]

where [i64; N]: Pod,

type Item<'a> = &'a [[i64; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[i64; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u8; N]

where [u8; N]: Pod,

type Item<'a> = &'a [[u8; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[u8; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u16; N]

where [u16; N]: Pod,

type Item<'a> = &'a [[u16; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[u16; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u32; N]

where [u32; N]: Pod,

type Item<'a> = &'a [[u32; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[u32; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [u64; N]

where [u64; N]: Pod,

type Item<'a> = &'a [[u64; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[u64; N] as ChunkComponentSlicer>::Item<'a>> + 'a

impl<const N: usize> ChunkComponentSlicer for [f16; N]

where [f16; N]: Pod,

type Item<'a> = &'a [[f16; N]]

fn slice<'a>( component_name: ComponentName, array: &'a dyn Array, component_offsets: impl Iterator<Item = (usize, usize)> + 'a, ) -> impl Iterator<Item = <[f16; N] as ChunkComponentSlicer>::Item<'a>> + 'a

Implementors