Trait radn::flow::binary::BinaryTrees

pub trait BinaryTrees: Keyed {
    type Node: Send;
    type Reference: Send;
    type Tree: Send;

    // Required methods
    fn split(&self, node: &Self::Node) -> Split<Self>;
    fn equal(&self, rl: &Self::Reference, rr: &Self::Reference) -> bool;
    fn refer(&self, tree: &Self::Tree) -> Option<Self::Reference>;
}

Required Associated Types

type Node: Send

type Reference: Send

type Tree: Send

Required Methods

fn split(&self, node: &Self::Node) -> Split<Self>

fn equal(&self, rl: &Self::Reference, rr: &Self::Reference) -> bool

fn refer(&self, tree: &Self::Tree) -> Option<Self::Reference>

Implementors

impl<'a, Ctx: Context<'a>, A: Mentionable<'a, Ctx> + Clone, C: 'a + Comparator<A>, E: 'a + Send> BinaryTrees for TreeContext2<'a, Ctx, A, C, E>

type Node = Node<'a, Ctx, A>

type Reference = Point<'a, Ctx, <TreeContext<(Arc<C>, <A as MentionableBase<'a>>::Fctr), (&'a (), Ctx, A, E)> as BinaryTrees>::Node>

type Tree = Tree<'a, Ctx, A>

impl<A: Send + Sync + Ord + Clone> BinaryTrees for Trees<A>

type Node = Node<A>

type Reference = Reference<A>

type Tree = Tree<A>

impl<BT: WithComparator + BinaryTrees> BinaryTrees for BoundTrees<BT>

type Node = BoundNode<<BoundTrees<BT> as Keyed>::Key, <BT as BinaryTrees>::Node>

type Reference = Bound<<BoundTrees<BT> as Keyed>::Key, <BT as BinaryTrees>::Reference>

type Tree = Bound<<BoundTrees<BT> as Keyed>::Key, <BT as BinaryTrees>::Tree>

impl<BT: TreesHeight> BinaryTrees for BalancedTrees<BT>

type Node = <BT as BinaryTrees>::Node

type Reference = (<BT as BinaryTrees>::Reference, u64)

type Tree = <BT as BinaryTrees>::Tree