Struct differential_dataflow::trace::layers::ordered_leaf::OrderedLeaf

pub struct OrderedLeaf<K, R, C = Vec<(K, R)>>where
    C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]>,{
    pub vals: C,
}

A layer of unordered values.

Fields

vals: C

Unordered values.

Trait Implementations

impl<K, R, C> Abomonation for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]> + Abomonation,

unsafe fn entomb<W: Write>(&self, _write: &mut W) -> Result<()>

Write any additional information about &self beyond its binary representation.

fn extent(&self) -> usize

Reports the number of further bytes required to entomb self.

unsafe fn exhume<'a, 'b>( &'a mut self, bytes: &'b mut [u8] ) -> Option<&'b mut [u8]>

Recover any information for &mut self not evident from its binary representation.

impl<K: Clone, R: Clone, C> Clone for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]> + Clone,

fn clone(&self) -> OrderedLeaf<K, R, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Clone, R: Clone, C> Cursor<OrderedLeaf<K, R, C>> for OrderedLeafCursorwhere C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]>,

type Key = (K, R)

The type revealed by the cursor.

fn key<'a>(&self, storage: &'a OrderedLeaf<K, R, C>) -> &'a Self::Key

Reveals the current key.

fn step(&mut self, storage: &OrderedLeaf<K, R, C>)

Advances the cursor by one element.

fn seek(&mut self, _storage: &OrderedLeaf<K, R, C>, _key: &Self::Key)

Advances the cursor until the location where key would be expected.

fn valid(&self, _storage: &OrderedLeaf<K, R, C>) -> bool

Returns true if the cursor points at valid data. Returns false if the cursor is exhausted.

fn rewind(&mut self, _storage: &OrderedLeaf<K, R, C>)

Rewinds the cursor to its initial state.

fn reposition( &mut self, _storage: &OrderedLeaf<K, R, C>, lower: usize, upper: usize )

Repositions the cursor to a different range of values.

impl<K: Debug, R: Debug, C> Debug for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]> + Debug,

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

Formats the value using the given formatter.

impl<K: PartialEq, R: PartialEq, C> PartialEq for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]> + PartialEq,

fn eq(&self, other: &OrderedLeaf<K, R, C>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<K: Ord + Clone, R: Semigroup + Clone, C> Trie for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]>,

type Item = (K, R)

The type of item from which the type is constructed.

type Cursor = OrderedLeafCursor

The type of cursor used to navigate the type.

type MergeBuilder = OrderedLeafBuilder<K, R, C>

The type used to merge instances of the type together.

type TupleBuilder = OrderedLeafBuilder<K, R, C>

The type used to assemble instances of the type from its Items.

fn keys(&self) -> usize

The number of distinct keys, as distinct from the total number of tuples.

fn tuples(&self) -> usize

The total number of tuples in the collection.

fn cursor_from(&self, lower: usize, upper: usize) -> Self::Cursor

Returns a cursor over a range of data, commonly used by others to restrict navigation to sub-collections.

fn cursor(&self) -> Self::Cursor

Returns a cursor capable of navigating the collection.

fn merge(&self, other: &Self) -> Self

Merges two collections into a third.

impl<K: Eq, R: Eq, C> Eq for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]> + Eq,

impl<K, R, C> StructuralEq for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]>,

impl<K, R, C> StructuralPartialEq for OrderedLeaf<K, R, C>where C: BatchContainer<Item = (K, R)> + Deref<Target = [(K, R)]>,