Struct generational_arena_tree::split::Leaf

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

Available on crate feature split only.

The node representing leaves in a split node tree.

Leaves are nodes which may not have children, as opposed to branches, which may have children.

LeafData represents the custom data associated with leaf nodes.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<BranchData, LeafData> Hash for Leaf<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 Leaf<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 Leaf<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type Base = SplitNode<BranchData, LeafData>

The ‘base node’ used in the arena.

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

The token associated with this type of node.

type Data = LeafData

The custom data associated with this node.

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

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

type DataRefMut<'data> = &'data mut LeafData 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) -> Self::Token

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::Base as BaseNode>::Branch>>

Returns the token of this node’s parent.

fn data(&self) -> &LeafData

Returns a reference to the data associated with this node.

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

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 Leaf<BranchData, LeafData>

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

fn eq(&self, other: &Other) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method 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 Leaf<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 Leaf<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 Leaf<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,