Struct re_query::FlatVecDeque

pub struct FlatVecDeque<T> { /* private fields */ }

A double-ended queue implemented with a pair of growable ring buffers, where every single entry is a flattened array of values.

Logically like a VecDeque<Box<[T]>>, but with a less fragmented memory layout (each Box<[T]> gets copied/inlined into the FlatVecDeque). FlatVecDeque therefore optimizes for reads (cache locality, specifically) while VecDeque<Box<[T]>> optimizes for writes.

You can think of this as the native/deserialized version of an Arrow ListArray. This is particularly useful when working with many small arrays of data (e.g. Rerun’s Scalars).

Implementations

impl<T> FlatVecDeque<T>

pub const fn new() -> Self

pub fn from_vecs(entries: impl IntoIterator<Item = Vec<T>>) -> Self

pub fn num_entries(&self) -> usize

How many entries are there in the deque?

Keep in mind: each entry is itself an array of values. Use Self::num_values to get the total number of values across all entries.

pub fn num_values(&self) -> usize

How many values are there in the deque?

Keep in mind: each entry in the deque holds an array of values. Use Self::num_entries to get the total number of entries, irrelevant of how many values each entry holds.

impl<T> FlatVecDeque<T>

pub fn iter(&self) -> impl Iterator<Item = &[T]>

Iterates over all the entries in the deque.

This is the same as self.range(0..self.num_entries()).

Keep in mind that each entry is an array of values!

pub fn range(&self, entry_range: Range<usize>) -> impl Iterator<Item = &[T]>

Iterates over all the entries in the deque in the given entry_range.

Keep in mind that each entry is an array of values!

impl<T> FlatVecDeque<T>

pub fn push_front(&mut self, values: impl IntoIterator<Item = T>)

Prepends an entry comprised of values to the deque.

This is the same as self.insert(0, values).

See Self::insert for more information.

pub fn push_back(&mut self, values: impl IntoIterator<Item = T>)

Appends an entry comprised of values to the deque.

This is the same as self.insert(self.num_entries(), values).

See Self::insert for more information.

pub fn insert( &mut self, entry_index: usize, values: impl IntoIterator<Item = T> )

Inserts a single entry at entry_index, comprised of the multiple elements given as values.

This is O(1) if entry_index corresponds to either the start or the end of the deque. Otherwise, this requires splitting the deque into two pieces then stitching them back together at both ends of the added data.

Panics if entry_index is out of bounds. Panics if values is empty.

pub fn push_many_front(&mut self, entries: impl IntoIterator<Item = Vec<T>>)

Prepends multiple entries, each comprised of the multiple elements given in entries, to the deque.

This is the same as self.insert_many(0, entries).

See Self::insert_many for more information.

pub fn push_many_back(&mut self, entries: impl IntoIterator<Item = Vec<T>>)

Appends multiple entries, each comprised of the multiple elements given in entries, to the deque.

This is the same as self.insert_many(self.num_entries(), entries).

See Self::insert_many for more information.

pub fn insert_many( &mut self, entry_index: usize, entries: impl IntoIterator<Item = Vec<T>> )

Inserts multiple entries, starting at entry_index onwards, each comprised of the multiple elements given in entries.

This is O(1) if entry_index corresponds to either the start or the end of the deque. Otherwise, this requires splitting the deque into two pieces then stitching them back together at both ends of the added data.

Panics if entry_index is out of bounds. Panics if any of the value arrays in entries is empty.

pub fn push_front_deque(&mut self, rhs: FlatVecDeque<T>)

Prepends another full deque to the deque.

This is the same as self.insert_deque(0, rhs).

See Self::insert_deque for more information.

pub fn push_back_deque(&mut self, rhs: FlatVecDeque<T>)

Appends another full deque to the deque.

This is the same as self.insert_deque(0, rhs).

See Self::insert_deque for more information.

pub fn insert_deque(&mut self, entry_index: usize, rhs: FlatVecDeque<T>)

Inserts another full deque, starting at entry_index and onwards.

This is O(1) if entry_index corresponds to either the start or the end of the deque. Otherwise, this requires splitting the deque into two pieces then stitching them back together at both ends of the added data.

Panics if entry_index is out of bounds. Panics if any of the value arrays in entries is empty.

impl<T> FlatVecDeque<T>

pub fn split_off(&mut self, entry_index: usize) -> Self

Splits the deque into two at the given index.

Returns a newly allocated FlatVecDeque. self contains entries [0, entry_index), and the returned deque contains entries [entry_index, num_entries).

Note that the capacity of self does not change.

Panics if entry_index is out of bounds.

pub fn truncate(&mut self, entry_index: usize)

Shortens the deque, keeping all entries up to entry_index (excluded), and dropping the rest.

If entry_index is greater or equal to Self::num_entries, this has no effect.

pub fn remove(&mut self, entry_index: usize)

Removes the entry at entry_index from the deque.

This is O(1) if entry_index corresponds to either the start or the end of the deque. Otherwise, this requires splitting the deque into three pieces, dropping the superfluous one, then stitching the two remaining pices back together.

Panics if entry_index is out of bounds.

pub fn remove_range(&mut self, entry_range: Range<usize>)

Removes all entries within the given entry_range from the deque.

This is O(1) if entry_range either starts at the beginning of the deque, or ends at the end of the deque, or both. Otherwise, this requires splitting the deque into three pieces, dropping the superfluous one, then stitching the two remaining pieces back together.

Panics if entry_range is either out of bounds or isn’t monotonically increasing.

Trait Implementations

impl<T: Clone> Clone for FlatVecDeque<T>

fn clone(&self) -> FlatVecDeque<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for FlatVecDeque<T>

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

Formats the value using the given formatter.

impl<T> Default for FlatVecDeque<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> ErasedFlatVecDeque for FlatVecDeque<T>

where T: Send + Sync + Clone + SizeBytes + 'static,

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn dyn_clone(&self) -> Box<dyn ErasedFlatVecDeque + Send + Sync>

Dynamically dispatches to FlatVecDeque::clone.

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn dyn_num_entries(&self) -> usize

Dynamically dispatches to FlatVecDeque::num_entries.

fn dyn_num_values(&self) -> usize

Dynamically dispatches to FlatVecDeque::num_values.

fn dyn_remove(&mut self, at: usize)

Dynamically dispatches to FlatVecDeque::remove.

fn dyn_remove_range(&mut self, range: Range<usize>)

Dynamically dispatches to FlatVecDeque::remove.

fn dyn_truncate(&mut self, at: usize)

Dynamically dispatches to FlatVecDeque::truncate.

fn dyn_total_size_bytes(&self) -> u64

Dynamically dispatches to [<FlatVecDeque<T> as SizeBytes>::total_size_bytes(self)].

impl<T> From<Vec<T>> for FlatVecDeque<T>

fn from(values: Vec<T>) -> Self

Converts to this type from the input type.

impl<T> From<VecDeque<T>> for FlatVecDeque<T>

fn from(values: VecDeque<T>) -> Self

Converts to this type from the input type.

impl<T: SizeBytes> SizeBytes for FlatVecDeque<T>

fn heap_size_bytes(&self) -> u64

Returns the total size of self on the heap, in bytes.

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

fn is_pod() -> bool

Is Self just plain old data?