Trait rerun::external::re_chunk::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

Object Safety

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