Struct RleCursor

pub struct RleCursor<const B: usize, P: Packable + ?Sized, X = SlabWeight> { /* private fields */ }

Trait Implementations

impl<const B: usize, P: Packable + ?Sized, X> Clone for RleCursor<B, P, X>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<const B: usize, P: Packable + ?Sized, X: HasPos + HasAcc + SpanWeight<Slab>> ColumnCursor for RleCursor<B, P, X>

type Item = P

type State<'a> = RleState<'a, P> where P: 'a

type PostState<'a> = Option<Run<'a, <RleCursor<B, P, X> as ColumnCursor>::Item>> where Self::Item: 'a

type Export = Option<<P as ToOwned>::Owned>

type SlabIndex = X

fn empty() -> Self

fn acc(&self) -> Acc

fn copy_between<'a>( slab: &'a [u8], writer: &mut SlabWriter<'a, P>, c0: Self, c1: Self, run: Run<'a, Self::Item>, size: usize, ) -> Self::State<'a>

fn finalize_state<'a>( slab: &'a Slab, encoder: &mut Encoder<'a, Self>, post: Option<Run<'a, P>>, cursor: Self, ) -> Option<Self>

fn finish<'a>(slab: &'a Slab, writer: &mut SlabWriter<'a, P>, cursor: Self)

fn slab_size() -> usize

fn splice_encoder( index: usize, del: usize, slab: &Slab, ) -> SpliceEncoder<'_, Self>

fn export_splice<'a, I>( data: &mut Vec<Self::Export>, range: Range<usize>, values: I, )

where I: Iterator<Item = Option<Cow<'a, Self::Item>>>, Self::Item: 'a,

fn compute_min_max(slabs: &mut [Slab])

fn min(&self) -> Agg

fn max(&self) -> Agg

fn try_next<'a>( &mut self, slab: &'a [u8], ) -> Result<Option<Run<'a, Self::Item>>, PackError>

fn index(&self) -> usize

fn offset(&self) -> usize

fn load_with(data: &[u8], m: &ScanMeta) -> Result<ColumnData<Self>, PackError>

fn encode<'a, I>(out: &mut Vec<u8>, values: I, force: bool) -> Range<usize>

where I: Iterator<Item = Option<Cow<'a, Self::Item>>>, Self::Item: 'a,

fn new(_: &Slab) -> Self

fn iter(slab: &[u8]) -> CursorIter<'_, Self>

fn is_empty(v: Option<Cow<'_, Self::Item>>) -> bool

fn contains_range( &self, run: &Run<'_, Self::Item>, range: &Range<usize>, ) -> Option<Range<usize>>

fn contains( &self, run: &Run<'_, Self::Item>, target: Agg, ) -> Option<Range<usize>>

fn contains_agg( &self, run: &Run<'_, Self::Item>, agg: Agg, ) -> Option<Range<usize>>

fn pop<'a>( &self, run: &mut Run<'a, Self::Item>, ) -> Option<Option<Cow<'a, Self::Item>>>

fn pop_n<'a>( &self, run: &mut Run<'a, Self::Item>, n: usize, ) -> Option<Option<Cow<'a, Self::Item>>>

fn next<'a>(&mut self, data: &'a [u8]) -> Option<Run<'a, Self::Item>>

fn seek(index: usize, slab: &Slab) -> (Option<Run<'_, Self::Item>>, Self)

fn debug_scan(data: &[u8], m: &ScanMeta) -> Result<Self, PackError>

fn load(data: &[u8]) -> Result<ColumnData<Self>, PackError>

fn splice<'a, 'b, I, M>( slab: &'a Slab, index: usize, del: usize, values: I, debug: (&mut Vec<Self::Export>, Range<usize>), ) -> SpliceResult

where M: MaybePackable<'b, Self::Item>, I: Iterator<Item = M>, Self::Item: 'b,

fn splice_delete<'a>( _post: Option<Run<'a, Self::Item>>, _cursor: Self, _del: usize, slab: &'a Slab, ) -> SpliceDel<'a, Self>

fn init_empty(len: usize) -> Slab

impl<const B: usize, P: Debug + Packable + ?Sized, X: Debug> Debug for RleCursor<B, P, X>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const B: usize, P: Packable + ?Sized, X> Default for RleCursor<B, P, X>

fn default() -> Self

Returns the “default value” for a type.

impl<const B: usize, P: PartialEq + Packable + ?Sized, X: PartialEq> PartialEq for RleCursor<B, P, X>

fn eq(&self, other: &RleCursor<B, P, X>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const B: usize, P: Packable + ?Sized, X> Copy for RleCursor<B, P, X>

impl<const B: usize, P: Packable + ?Sized, X> StructuralPartialEq for RleCursor<B, P, X>