Trait ITokenKeyExprTree

source

pub trait ITokenKeyExprTree<'a, Weight, Token> {
Show 37 associated items
    type Node: IKeyExprTreeNode<Weight>;
    type NodeMut: IKeyExprTreeNodeMut<Weight>;
    type TreeIterItem;
    type TreeIter: Iterator<Item = Self::TreeIterItem>;
    type TreeIterItemMut;
    type TreeIterMut: Iterator<Item = Self::TreeIterItemMut>;
    type IntersectionItem;
    type Intersection: Iterator<Item = Self::IntersectionItem>;
    type IntersectionItemMut;
    type IntersectionMut: Iterator<Item = Self::IntersectionItemMut>;
    type InclusionItem;
    type Inclusion: Iterator<Item = Self::InclusionItem>;
    type InclusionItemMut;
    type InclusionMut: Iterator<Item = Self::InclusionItemMut>;
    type IncluderItem;
    type Includer: Iterator<Item = Self::IncluderItem>;
    type IncluderItemMut;
    type IncluderMut: Iterator<Item = Self::IncluderItemMut>;
    type PruneNode: IKeyExprTreeNodeMut<Weight>;

    // Required methods
    fn node(&'a self, token: &'a Token, key: &keyexpr) -> Option<Self::Node>;
    fn node_mut(
        &'a self,
        token: &'a mut Token,
        key: &keyexpr,
    ) -> Option<Self::NodeMut>;
    fn node_or_create(
        &'a self,
        token: &'a mut Token,
        key: &keyexpr,
    ) -> Self::NodeMut;
    fn tree_iter(&'a self, token: &'a Token) -> Self::TreeIter;
    fn tree_iter_mut(&'a self, token: &'a mut Token) -> Self::TreeIterMut;
    fn intersecting_nodes(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> Self::Intersection;
    fn intersecting_nodes_mut(
        &'a self,
        token: &'a mut Token,
        key: &'a keyexpr,
    ) -> Self::IntersectionMut;
    fn included_nodes(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> Self::Inclusion;
    fn included_nodes_mut(
        &'a self,
        token: &'a mut Token,
        key: &'a keyexpr,
    ) -> Self::InclusionMut;
    fn nodes_including(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> Self::Includer;
    fn nodes_including_mut(
        &'a self,
        token: &'a mut Token,
        key: &'a keyexpr,
    ) -> Self::IncluderMut;
    fn prune_where<F: FnMut(&mut Self::PruneNode) -> bool>(
        &self,
        token: &mut Token,
        predicate: F,
    );

    // Provided methods
    fn insert(
        &'a self,
        token: &'a mut Token,
        at: &keyexpr,
        weight: Weight,
    ) -> Option<Weight> { ... }
    fn remove(
        &'a mut self,
        token: &'a mut Token,
        key: &keyexpr,
    ) -> Option<Weight> { ... }
    fn intersecting_keys(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> FilterMap<Self::Intersection, fn(_: Self::IntersectionItem) -> Option<OwnedKeyExpr>> ⓘ
       where Self::IntersectionItem: AsNode<Self::Node>,
             Self::Node: IKeyExprTreeNode<Weight> { ... }
    fn included_keys(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> FilterMap<Self::Inclusion, fn(_: Self::InclusionItem) -> Option<OwnedKeyExpr>> ⓘ
       where Self::InclusionItem: AsNode<Self::Node>,
             Self::Node: IKeyExprTreeNode<Weight> { ... }
    fn keys_including(
        &'a self,
        token: &'a Token,
        key: &'a keyexpr,
    ) -> FilterMap<Self::Includer, fn(_: Self::IncluderItem) -> Option<OwnedKeyExpr>> ⓘ
       where Self::IncluderItem: AsNode<Self::Node>,
             Self::Node: IKeyExprTreeNode<Weight> { ... }
    fn prune(&self, token: &mut Token) { ... }
}

Expand description

The basic operations of a KeTree when a Token is necessary to access data.

Required Associated Types§

source

type Node: IKeyExprTreeNode<Weight>

An immutable guard to a node of the tree.

source

type PruneNode: IKeyExprTreeNodeMut<Weight>

Required Methods§

source

fn node(&'a self, token: &'a Token, key: &keyexpr) -> Option<Self::Node>

Accesses the node at key if it exists, treating KEs as if they were completely verbatim keys.

Returns None if key is not present in the KeTree.

source

fn node_mut( &'a self, token: &'a mut Token, key: &keyexpr, ) -> Option<Self::NodeMut>

Mutably accesses the node at key if it exists, treating KEs as if they were completely verbatim keys.

Returns None if key is not present. Use IKeyExprTreeMut::node_mut_or_create if you wish to construct the node if it doesn’t exist.

source

fn node_or_create( &'a self, token: &'a mut Token, key: &keyexpr, ) -> Self::NodeMut

Mutably accesses the node at key, creating it if necessary.

source

fn tree_iter(&'a self, token: &'a Token) -> Self::TreeIter

Iterates over the whole tree, including nodes with no weight.

source

fn tree_iter_mut(&'a self, token: &'a mut Token) -> Self::TreeIterMut

Iterates over the whole tree, including nodes with no weight.

source