Struct lattices::ght::GhtLeaf

pub struct GhtLeaf<Schema, ValType, Storage>
where
    Schema: Eq + Hash,
    Storage: VariadicCollection<Schema = Schema>,
{ /* private fields */ }

leaf node of a HashTrie

Trait Implementations

impl<Schema, ValType: Clone, Storage> Clone for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash + Clone, Storage: VariadicCollection<Schema = Schema> + Clone,

fn clone(&self) -> GhtLeaf<Schema, ValType, Storage>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Schema, Head, Rest, Storage> ColtForestNode for GhtLeaf<Schema, (Head, Rest), Storage>

where Head: 'static + Clone + Hash + Eq, Rest: 'static + Clone + Hash + Eq + VariadicExt + PartialEqVariadic, Schema: 'static + Hash + Eq + Clone + VariadicExt + PartialEqVariadic + SplitBySuffix<(Head, Rest)> + SplitBySuffix<Rest>, <Schema as SplitBySuffix<(Head, Rest)>>::Prefix: Eq + Hash + Clone, <Schema as SplitBySuffix<Rest>>::Prefix: Eq + Hash + Clone, Storage: VariadicCollection<Schema = Schema> + Default + IntoIterator<Item = Schema>, GhtLeaf<Schema, Rest, Storage>: GeneralizedHashTrieNode<Schema = Schema, Storage = Storage>, GhtInner<Head, GhtLeaf<Schema, Rest, Storage>>: GeneralizedHashTrieNode<Schema = Schema, Storage = Storage>,

type Force = GhtInner<Head, GhtLeaf<Schema, Rest, Storage>>

result of forceing a node

fn force(self) -> Option<Self::Force>

Force the generation of a parent node, as in the Wang/Willsey/Suciu COLT structure, to be merged into the next trie to the right.

fn force_drain( &mut self, ) -> Option<GhtInner<Head, GhtLeaf<Schema, Rest, Storage>>>

Force the generation of a parent node but retain ref to this node

impl<Schema, ValType: Debug, Storage> Debug for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash + Debug, Storage: VariadicCollection<Schema = Schema> + Debug,

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

Formats the value using the given formatter.

impl<Schema, ValType, Storage> Default for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash, Storage: VariadicCollection<Schema = Schema> + Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Schema, ValType, Storage> FromIterator<Schema> for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash, Storage: VariadicCollection<Schema = Schema> + Default + FromIterator<Schema>,

fn from_iter<Iter: IntoIterator<Item = Schema>>(iter: Iter) -> Self

Creates a value from an iterator.

impl<Schema, Storage> GeneralizedHashTrieNode for GhtLeaf<Schema, (), Storage>

where Schema: 'static + Eq + VariadicExt + Hash + Clone + PartialEqVariadic, Storage: VariadicCollection<Schema = Schema> + Default + IntoIterator<Item = Schema>,

type Schema = Schema

Schema variadic: the schema of the relation stored in this trie.

type SuffixSchema = ()

SuffixSchema variadic: the suffix of Self::Schema from this node of the trie downward. The first entry in this variadic is of type Self::Head.

type ValType = ()

The suffix of columns in Self::Schema that are not part of the trie keys

type KeyType = Schema

The prefix of columns in Self::Schema that the trie is keyed on

type Head = ()

The first field in Self::SuffixSchema, and the key for the next node in the trie.

type Storage = Storage

The type that holds the data in the leaves

fn new_from(input: impl IntoIterator<Item = Self::Schema>) -> Self

Create a new Ght from the iterator.

fn merge_node(&mut self, other: Self) -> bool

Merge a matching Ght node into this node

const HEIGHT: usize = 0usize

The height of this node in the GhT. Leaf = 0.

fn insert(&mut self, row: Self::Schema) -> bool

Inserts an item into the hash trie.

fn contains<'a>( &'a self, row: <Self::Schema as VariadicExt>::AsRefVar<'a>, ) -> bool

Returns true if the (entire) row is found below in the trie, false otherwise. See GhtGet::get to look just for “head” keys in this node

fn recursive_iter( &self, ) -> impl Iterator<Item = <Self::Schema as VariadicExt>::AsRefVar<'_>>

Iterate through (entire) rows stored in this HashTrie.

fn find_containing_leaf( &self, row: <Self::Schema as VariadicExt>::AsRefVar<'_>, ) -> Option<&GhtLeaf<<Self as GeneralizedHashTrieNode>::Schema, Self::ValType, Self::Storage>>

return the leaf below that contains this row, or None if not found.

fn into_iter(self) -> Option<impl Iterator<Item = Self::Schema>>

into_iter for leaf elements, or None for inner nodes

fn drain(&mut self) -> Option<impl Iterator<Item = Self::Schema>>

pull all the data out of this trie node but retain the reference

fn height(&self) -> usize

Report the height of this node. This is the length of path from this node to a leaf - 1. E.g. if we have GhtInner<GhtInner<GhtLeaf…>> the height is 2 This is a static property of the type of this node, so simply invokes the static method.

impl<Schema, ValHead, ValRest, Storage> GeneralizedHashTrieNode for GhtLeaf<Schema, (ValHead, ValRest), Storage>

where Schema: 'static + Eq + VariadicExt + Hash + Clone + SplitBySuffix<(ValHead, ValRest)> + PartialEqVariadic, ValHead: Clone + Eq + Hash, (ValHead, ValRest): Clone + Eq + Hash + PartialEqVariadic, <Schema as SplitBySuffix<(ValHead, ValRest)>>::Prefix: Eq + Hash + Clone, Storage: VariadicCollection<Schema = Schema> + Default + IntoIterator<Item = Schema>,

type Schema = Schema

Schema variadic: the schema of the relation stored in this trie.

type SuffixSchema = (ValHead, ValRest)

SuffixSchema variadic: the suffix of Self::Schema from this node of the trie downward. The first entry in this variadic is of type Self::Head.

type ValType = (ValHead, ValRest)

The suffix of columns in Self::Schema that are not part of the trie keys

type KeyType = <Schema as SplitBySuffix<(ValHead, ValRest)>>::Prefix

The prefix of columns in Self::Schema that the trie is keyed on

type Head = ValHead

The first field in Self::SuffixSchema, and the key for the next node in the trie.

type Storage = Storage

The type that holds the data in the leaves

fn new_from(input: impl IntoIterator<Item = Self::Schema>) -> Self

Create a new Ght from the iterator.

fn merge_node(&mut self, other: Self) -> bool

Merge a matching Ght node into this node

const HEIGHT: usize = 0usize

The height of this node in the GhT. Leaf = 0.

fn insert(&mut self, row: Self::Schema) -> bool

Inserts an item into the hash trie.

fn contains<'a>( &'a self, row: <Self::Schema as VariadicExt>::AsRefVar<'a>, ) -> bool

Returns true if the (entire) row is found below in the trie, false otherwise. See GhtGet::get to look just for “head” keys in this node

fn recursive_iter( &self, ) -> impl Iterator<Item = <Self::Schema as VariadicExt>::AsRefVar<'_>>

Iterate through (entire) rows stored in this HashTrie.

fn find_containing_leaf( &self, row: <Self::Schema as VariadicExt>::AsRefVar<'_>, ) -> Option<&GhtLeaf<<Self as GeneralizedHashTrieNode>::Schema, Self::ValType, Self::Storage>>

return the leaf below that contains this row, or None if not found.

fn into_iter(self) -> Option<impl Iterator<Item = Self::Schema>>

into_iter for leaf elements, or None for inner nodes

fn drain(&mut self) -> Option<impl Iterator<Item = Self::Schema>>

pull all the data out of this trie node but retain the reference

fn height(&self) -> usize

Report the height of this node. This is the length of path from this node to a leaf - 1. E.g. if we have GhtInner<GhtInner<GhtLeaf…>> the height is 2 This is a static property of the type of this node, so simply invokes the static method.

impl<Schema, ValType, Storage> GhtGet for GhtLeaf<Schema, ValType, Storage>

where Schema: 'static + Eq + Hash + Clone + PartialEqVariadic + SplitBySuffix<ValType>, ValType: Eq + Hash + Clone + PartialEqVariadic, <Schema as SplitBySuffix<ValType>>::Prefix: Eq + Hash + Clone, GhtLeaf<Schema, ValType, Storage>: GeneralizedHashTrieNode<Schema = Schema>, Storage: VariadicCollection<Schema = Schema>,

type Get = GhtLeaf<Schema, ValType, Storage>

Type returned by Self::get.

fn get<'a>(&'a self, _head: &Self::Head) -> Option<&'a Self::Get>

On an Inner node, retrieves the value (child) associated with the given “head” key. returns an Option containing a reference to the value if found, or None if not found. On a Leaf node, returns None.

fn get_mut<'a>(&'a mut self, _head: &Self::Head) -> Option<&'a mut Self::Get>

get, but mutable output

fn iter(&self) -> impl Iterator<Item = Self::Head>

Iterator for the “head” keys (from inner nodes) or nothing (from leaf nodes).

fn iter_tuples( &self, ) -> impl Iterator<Item = <Self::Schema as VariadicExt>::AsRefVar<'_>>

Iterator for the tuples (from leaf nodes) or nothing (from inner nodes).

impl<KeyPrefixRef, Schema, ValType, Storage> GhtPrefixIter<KeyPrefixRef> for GhtLeaf<Schema, ValType, Storage>

where KeyPrefixRef: 'static + RefVariadic, Schema: 'static + VariadicExt + Hash + Eq + SplitBySuffix<ValType>, ValType: VariadicExt + Split<KeyPrefixRef::UnRefVar>, KeyPrefixRef::UnRefVar: PartialEqVariadic, Storage: 'static + VariadicCollection<Schema = Schema>,

type Item = Schema

the schema output

fn prefix_iter<'a>( &'a self, prefix: KeyPrefixRef, ) -> impl Iterator<Item = <Self::Item as VariadicExt>::AsRefVar<'a>>

where Self::Item: 'a,

given a prefix, return an iterator through the items below

impl<Schema, SuffixSchema, Storage> IsBot for GhtLeaf<Schema, SuffixSchema, Storage>

where Schema: Eq + Hash, SuffixSchema: Eq + Hash, Storage: VariadicSet<Schema = Schema>,

fn is_bot(&self) -> bool

Returns if self is lattice bottom (⊥).

impl<Schema, SuffixSchema, Storage> IsTop for GhtLeaf<Schema, SuffixSchema, Storage>

where Schema: Eq + Hash, SuffixSchema: Eq + Hash, Storage: VariadicSet<Schema = Schema>,

fn is_top(&self) -> bool

Returns if self is lattice top (⊤).

impl<Schema, ValType, Storage> Merge<GhtLeaf<Schema, ValType, Storage>> for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash, Storage: VariadicSet<Schema = Schema> + Extend<Schema> + IntoIterator<Item = Schema>,

fn merge(&mut self, other: GhtLeaf<Schema, ValType, Storage>) -> bool

Merge other into the self lattice.

fn merge_owned(this: Self, delta: Other) -> Self

where Self: Sized,

Merge this and delta together, returning the new value.

impl<Schema, ValType: PartialEq, Storage> PartialEq for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash + PartialEq, Storage: VariadicCollection<Schema = Schema> + PartialEq,

fn eq(&self, other: &GhtLeaf<Schema, ValType, Storage>) -> 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<Schema, SuffixSchema, Storage> PartialOrd for GhtLeaf<Schema, SuffixSchema, Storage>

where Schema: Eq + Hash + PartialEqVariadic, SuffixSchema: Eq + Hash, Storage: VariadicSet<Schema = Schema> + PartialEq,

fn partial_cmp( &self, other: &GhtLeaf<Schema, SuffixSchema, Storage>, ) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Schema, ValType: Eq, Storage> Eq for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash + Eq, Storage: VariadicCollection<Schema = Schema> + Eq,

impl<Schema, SuffixSchema, Storage> LatticeOrd for GhtLeaf<Schema, SuffixSchema, Storage>

where Schema: Eq + Hash + PartialEqVariadic, SuffixSchema: Eq + Hash, Storage: VariadicSet<Schema = Schema> + PartialEq,

impl<Schema, ValType, Storage> StructuralPartialEq for GhtLeaf<Schema, ValType, Storage>

where Schema: Eq + Hash, Storage: VariadicCollection<Schema = Schema>,