Struct Branch

pub struct Branch<BranchData: Debug, LeafData: Debug> { /* private fields */ }

Available on crate feature split only.

The node representing branches in a split node tree.

Branches are nodes which may have children, as opposed to leaves, which may not have children.

BranchData represents the custom data associated with branch nodes.

Trait Implementations

impl<BranchData, LeafData> BranchNode for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type ChildrenIter<'branch> = ChildrenLinked<'branch, Branch<BranchData, LeafData>> where Self: 'branch

The iterator returned by children.

fn first(&self) -> Option<<Self::Base as Node>::Token>

Returns the token of this branch node’s first child.

fn last(&self) -> Option<<Self::Base as Node>::Token>

Returns the token of this branch node’s last child.

fn children<'branch>( &'branch self, arena: &'branch Arena<Self::Base>, ) -> Self::ChildrenIter<'branch>

Returns an iterator over the tokens of this branch node’s children.

fn is_empty(&self) -> bool

Returns whether this branch node has no children.

fn detach_front( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<<Self::Base as Node>::Token>

Detaches this branch node’s first child, returning its token.

fn detach_back( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<<Self::Base as Node>::Token>

Detaches this branch node’s last child, returning its token.

fn pop_front( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<<Self::Base as BaseNode>::Representation>

Removes this branch node’s first child.

fn pop_back( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<<Self::Base as BaseNode>::Representation>

Removes this branch node’s last child.

fn push_front( token: Self::Token, arena: &mut Arena<Self::Base>, new: <Self::Base as Node>::Token, )

Pushes the given new token’s node to the beginning of this branch node’s children.

fn push_back( token: Self::Token, arena: &mut Arena<Self::Base>, new: <Self::Base as Node>::Token, )

Pushes the given new token’s node to the end of this branch node’s children.

fn descendants<'branch>( &'branch self, arena: &'branch Arena<Self::Base>, ) -> Descendants<'branch, Self>

where Self: Sized, for<'base> &'base Self: TryFrom<&'base Self::Base>,

Returns an iterator over the tokens of this branch node’s descendants.

impl<BranchData: Debug + Debug, LeafData: Debug + Debug> Debug for Branch<BranchData, LeafData>

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

Formats the value using the given formatter.

impl<BranchData, LeafData> Hash for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<BranchData, LeafData> LinkedNode for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

fn prev(&self) -> Option<<Self::Base as Node>::Token>

Returns the token of this node’s previous sibling.

fn next(&self) -> Option<<Self::Base as Node>::Token>

Returns the token of this node’s next sibling.

fn preceding_siblings<'node>( &'node self, arena: &'node Arena<Self::Base>, ) -> PrecedingSiblings<'node, Self>

where Self: Sized,

Returns an iterator over the tokens of this node’s preceding siblings.

fn following_siblings<'node>( &'node self, arena: &'node Arena<Self::Base>, ) -> FollowingSiblings<'node, Self>

where Self: Sized,

Returns an iterator over the tokens of this node’s following siblings.

impl<BranchData, LeafData> Node for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type Base = SplitNode<BranchData, LeafData>

The ‘base node’ used in the arena.

type Token = Token<Branch<BranchData, LeafData>>

The token associated with this type of node.

type Data = BranchData

The custom data associated with this node.

type DataRef<'data> = &'data BranchData where Self: 'data

A type acting as a reference to the node’s data.

type DataRefMut<'data> = &'data mut BranchData where Self: 'data

A type acting as a mutable reference to the node’s data.

fn new(arena: &mut Arena<Self::Base>, data: Self::Data) -> Token<Self>

Creates a new node allocated in the given arena using the given data.

fn token(&self) -> Self::Token

Returns this node’s token.

fn parent(&self) -> Option<Token<Self>>

Returns the token of this node’s parent.

fn data(&self) -> &BranchData

Returns a reference to the data associated with this node.

fn data_mut(&mut self) -> &mut BranchData

Returns a mutable reference to the data associated with this node.

fn ancestors<'node>( &'node self, arena: &'node Arena<Self::Base>, ) -> Ancestors<'node, Self::Base>

where Self: Sized,

Returns an iterator over the tokens of this node’s ancestors.

fn root<'node>(&'node self, arena: &'node Arena<Self::Base>) -> RootToken<Self>

where Self: Sized,

Returns this node’s root node.

impl<BranchData, LeafData, Other: Node> PartialEq<Other> for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug, <Self as Node>::Token: PartialEq<Other::Token>,

fn eq(&self, other: &Other) -> 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<'node, BranchData, LeafData> TryFrom<&'node SplitNode<BranchData, LeafData>> for &'node Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type Error = &'node SplitNode<BranchData, LeafData>

The type returned in the event of a conversion error.

fn try_from( node: &'node SplitNode<BranchData, LeafData>, ) -> Result<Self, Self::Error>

Performs the conversion.

impl<'node, BranchData, LeafData> TryFrom<&'node mut SplitNode<BranchData, LeafData>> for &'node mut Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type Error = &'node mut SplitNode<BranchData, LeafData>

The type returned in the event of a conversion error.

fn try_from( node: &'node mut SplitNode<BranchData, LeafData>, ) -> Result<Self, Self::Error>

Performs the conversion.

impl<BranchData, LeafData> Eq for Branch<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,