Enum mz_timely_util::containers::stack::StackWrapper

pub enum StackWrapper<T: Columnation> {
    Legacy(TimelyStack<T>),
    Chunked(ChunkedStack<T>),
}

A runtime-configurable wrapper around timely stacks and chunked stacks.

Variants

Legacy(TimelyStack<T>)

Chunked(ChunkedStack<T>)

Implementations

impl<T: Columnation> StackWrapper<T>

fn with_capacity(size: usize) -> Self

pub fn heap_size(&self, callback: impl FnMut(usize, usize))

Estimate the memory capacity in bytes.

Trait Implementations

impl<T: Ord + Columnation + Clone + 'static> BatchContainer for StackWrapper<T>

type Owned = T

An owned instance of Self::ReadItem<'_>.

type ReadItem<'a> = &'a <StackWrapper<T> as BatchContainer>::Owned

The type that can be read back out of the container.

fn with_capacity(size: usize) -> Self

Creates a new container with sufficient capacity.

fn merge_capacity(cont1: &Self, cont2: &Self) -> Self

Creates a new container with sufficient capacity.

fn reborrow<'b, 'a: 'b>(item: Self::ReadItem<'a>) -> Self::ReadItem<'b>

Converts a read item into one with a narrower lifetime.

fn index(&self, index: usize) -> Self::ReadItem<'_>

Reference to the element at this position.

fn len(&self) -> usize

Number of contained elements

fn is_empty(&self) -> bool

Indicates if the length is zero.

fn push<D>(&mut self, item: D)

where Self: PushInto<D>,

Push an item into this container

fn last(&self) -> Option<Self::ReadItem<'_>>

Returns the last item if the container is non-empty.

fn advance<F>(&self, start: usize, end: usize, function: F) -> usize

where F: for<'a> Fn(Self::ReadItem<'a>) -> bool,

Reports the number of elements satisfing the predicate.

impl<T: Clone + Columnation> Clone for StackWrapper<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Clone + Columnation + 'static> Container for StackWrapper<T>

type ItemRef<'a> = &'a T where Self: 'a

The type of elements when reading non-destructively from the container.

type Item<'a> = &'a T where Self: 'a

The type of elements when draining the container.

fn len(&self) -> usize

The number of elements in this container

fn is_empty(&self) -> bool

Determine if the container contains any elements, corresponding to len() == 0.

fn clear(&mut self)

Remove all contents from self while retaining allocated memory. After calling clear, is_empty must return true and len 0.

type Iter<'a> = Either<<TimelyStack<T> as Container>::Iter<'a>, <ChunkedStack<T> as Container>::Iter<'a>>

Iterator type when reading from the container.

fn iter(&self) -> Self::Iter<'_>

Returns an iterator that reads the contents of this container.

type DrainIter<'a> = Either<<TimelyStack<T> as Container>::DrainIter<'a>, <ChunkedStack<T> as Container>::DrainIter<'a>>

Iterator type when draining the container.

fn drain(&mut self) -> Self::DrainIter<'_>

Returns an iterator that drains the contents of this container. Drain leaves the container in an undefined state.

fn push<T>(&mut self, item: T)

where Self: PushInto<T>,

Push item into self

impl<T: Columnation> Default for StackWrapper<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for StackWrapper<T>

where T: Deserialize<'de> + Columnation,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Columnation + ToOwned<Owned = T> + 'static> PushInto<&T> for StackWrapper<T>

fn push_into(&mut self, item: &T)

Push item into self.

impl<T: Columnation + ToOwned<Owned = T> + 'static> PushInto<T> for StackWrapper<T>

fn push_into(&mut self, item: T)

Push item into self.

impl<T> Serialize for StackWrapper<T>

where T: Serialize + Columnation,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Clone + Columnation + 'static> SizableContainer for StackWrapper<T>

fn capacity(&self) -> usize

Return the capacity of the container.

fn preferred_capacity() -> usize

Return the preferred capacity of the container.

fn reserve(&mut self, additional: usize)

Reserve space for additional elements, possibly increasing the capacity of the container.