Trait zenoh_keyexpr::keyexpr_tree::traits::ITokenKeyExprTree

pub trait ITokenKeyExprTree<'a, Weight, Token> {
    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 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 prune_where<F: FnMut(&mut Self::PruneNode) -> bool>(
        &self,
        token: &mut Token,
        predicate: F
    );
}

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

Required Associated Types

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 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 prune_where<F: FnMut(&mut Self::PruneNode) -> bool>( &self, token: &mut Token, predicate: F )

Object Safety

This trait is not object safe.

Implementors

impl<'a, Weight: 'a, Wildness: IWildness + 'a, Children: IChildrenProvider<Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>> + 'a, Token: TokenTrait + 'a> ITokenKeyExprTree<'a, Weight, Token> for KeArcTree<Weight, Token, Wildness, Children>

where Children::Assoc: IChildren<Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>>,

type Node = (&'a Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, &'a Token)

type NodeMut = (&'a Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, &'a mut Token)

type TreeIterItem = <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::Node

type TreeIter = TokenPacker<TreeIter<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a Token>

type TreeIterItemMut = Tokenized<&'a Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, &'a mut Token>

type TreeIterMut = TokenPacker<TreeIter<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a mut Token>

type IntersectionItem = <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::Node

type Intersection = IterOrOption<TokenPacker<Intersection<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a Token>, <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::IntersectionItem>

type IntersectionItemMut = <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::TreeIterItemMut

type IntersectionMut = IterOrOption<TokenPacker<Intersection<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a mut Token>, <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::IntersectionItemMut>

type InclusionItem = <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::Node

type Inclusion = IterOrOption<TokenPacker<Inclusion<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a Token>, <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::InclusionItem>

type InclusionItemMut = <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::TreeIterItemMut

type InclusionMut = IterOrOption<TokenPacker<Inclusion<'a, Children, Arc<TokenCell<KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>, Token>>, Weight>, &'a mut Token>, <KeArcTree<Weight, Token, Wildness, Children> as ITokenKeyExprTree<'a, Weight, Token>>::InclusionItemMut>

type PruneNode = KeArcTreeNode<Weight, Weak<()>, Wildness, Children, Token>