Trait timely::container::Container

pub trait Container:
    Default
    + Clone
    + 'static {
    type ItemRef<'a>
       where Self: 'a;
    type Item<'a>
       where Self: 'a;
    type Iter<'a>: Iterator<Item = Self::ItemRef<'a>>;
    type DrainIter<'a>: Iterator<Item = Self::Item<'a>>;

    // Required methods
    fn len(&self) -> usize;
    fn clear(&mut self);
    fn iter(&self) -> Self::Iter<'_>;
    fn drain(&mut self) -> Self::DrainIter<'_>;

    // Provided methods
    fn push<T>(&mut self, item: T)
       where Self: PushInto<T> { ... }
    fn is_empty(&self) -> bool { ... }
}

A container transferring data through dataflow edges

A container stores a number of elements and thus is able to describe it length (len()) and whether it is empty (is_empty()). It supports removing all elements (clear).

A container must implement default. The default implementation is not required to allocate memory for variable-length components.

We require the container to be cloneable to enable efficient copies when providing references of containers to operators. Care must be taken that the type’s clone_from implementation is efficient (which is not necessarily the case when deriving Clone.) TODO: Don’t require Container: Clone

Required Associated Types

type ItemRef<'a> where Self: 'a

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

type Item<'a> where Self: 'a

The type of elements when draining the container.

type Iter<'a>: Iterator<Item = Self::ItemRef<'a>>

Iterator type when reading from the container.

type DrainIter<'a>: Iterator<Item = Self::Item<'a>>

Iterator type when draining the container.

Required Methods

fn len(&self) -> usize

The number of elements in this container

The length of a container must be consistent between sending and receiving it. When exchanging a container and partitioning it into pieces, the sum of the length of all pieces must be equal to the length of the original container. When combining containers, the length of the result must be the sum of the individual parts.

fn clear(&mut self)

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

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

Returns an iterator that reads the contents of this 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.

Provided Methods

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

where Self: PushInto<T>,

Push item into self

fn is_empty(&self) -> bool

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<T> Container for Rc<T>

where T: Container,

type ItemRef<'a> = <T as Container>::ItemRef<'a> where Rc<T>: 'a

type Item<'a> = <T as Container>::ItemRef<'a> where Rc<T>: 'a

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn clear(&mut self)

type Iter<'a> = <T as Container>::Iter<'a>

fn iter(&self) -> <Rc<T> as Container>::Iter<'_>

type DrainIter<'a> = <T as Container>::Iter<'a>

fn drain(&mut self) -> <Rc<T> as Container>::DrainIter<'_>

impl<T> Container for Arc<T>

where T: Container,

type ItemRef<'a> = <T as Container>::ItemRef<'a> where Arc<T>: 'a

type Item<'a> = <T as Container>::ItemRef<'a> where Arc<T>: 'a

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn clear(&mut self)

type Iter<'a> = <T as Container>::Iter<'a>

fn iter(&self) -> <Arc<T> as Container>::Iter<'_>

type DrainIter<'a> = <T as Container>::Iter<'a>

fn drain(&mut self) -> <Arc<T> as Container>::DrainIter<'_>

impl<T> Container for Vec<T>

where T: Clone + 'static,

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

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

fn len(&self) -> usize

fn is_empty(&self) -> bool

fn clear(&mut self)

type Iter<'a> = Iter<'a, T>

fn iter(&self) -> <Vec<T> as Container>::Iter<'_>

type DrainIter<'a> = Drain<'a, T>

fn drain(&mut self) -> <Vec<T> as Container>::DrainIter<'_>

Implementors

impl<R> Container for FlatStack<R>

where R: Region + Clone + 'static,

type ItemRef<'a> = <R as Region>::ReadItem<'a> where FlatStack<R>: 'a

type Item<'a> = <R as Region>::ReadItem<'a> where FlatStack<R>: 'a

type Iter<'a> = <&'a FlatStack<R> as IntoIterator>::IntoIter

type DrainIter<'a> = <FlatStack<R> as Container>::Iter<'a>

impl<T> Container for TimelyStack<T>

where T: Columnation + 'static,

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

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

type Iter<'a> = Iter<'a, T>

type DrainIter<'a> = Iter<'a, T>