Struct UnifiedNodeDeque

pub struct UnifiedNodeDeque<Data: Debug> { /* private fields */ }

Available on crate features deque and unified only.

A node that is not split into separate branch and leaf nodes.

This is the deque version, where children are represented as a VecDeque. In this version, a node’s previous sibling(s) and next sibling(s) are not available, but nodes can be directly indexed, and children can be detached, removed, or inserted by index.

Data represents the custom data associated with the node.

See also

For the non-deque version, see UnifiedNode. For a node that is split into separate branch and leaf nodes, see SplitNode and SplitNodeDeque.

Trait Implementations

impl<Data: Debug> BaseNode for UnifiedNodeDeque<Data>

type Representation = UnifiedNodeRepresentation<Data>

The representation of the node after it is removed from the arena.

type Branch = UnifiedNodeDeque<Data>

The type used for branch nodes.

type Leaf = UnifiedNodeDeque<Data>

The type used for leaf nodes.

fn into_representation(self, arena: &mut Arena<Self>) -> Self::Representation

Converts this node into its representation.

impl<Data: Debug> BranchNode for UnifiedNodeDeque<Data>

type ChildrenIter<'branch> = Copied<Iter<'branch, Token<UnifiedNodeDeque<Data>>>> where Self: 'branch

The iterator returned by children.

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

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

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

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<Token<Self>>

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

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

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

fn pop_front( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<UnifiedNodeRepresentation<Data>>

Removes this branch node’s first child.

fn pop_back( token: Self::Token, arena: &mut Arena<Self::Base>, ) -> Option<UnifiedNodeRepresentation<Data>>

Removes this branch node’s last child.

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

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: Token<Self>, )

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<Data: Debug> BranchNodeDeque for UnifiedNodeDeque<Data>

fn len(&self) -> usize

Returns the number of children this branch node has.

fn detach( token: Self::Token, arena: &mut Arena<Self>, index: usize, ) -> Token<Self>

Detaches the child at the given index, returning its token.

fn remove( token: Self::Token, arena: &mut Arena<Self>, index: usize, ) -> UnifiedNodeRepresentation<Data>

Removes the child at the given index.

fn insert( token: Self::Token, arena: &mut Arena<Self>, index: usize, new: Token<Self>, )

Inserts the given new token’s node at the given index.

fn get(&self, index: usize) -> Option<<Self::Base as Node>::Token>

Returns the token of the child at the given index.

impl<Data: Debug + Debug> Debug for UnifiedNodeDeque<Data>

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

Formats the value using the given formatter.

impl<Data: Debug> Hash for UnifiedNodeDeque<Data>

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<Data: Debug> Index<usize> for UnifiedNodeDeque<Data>

type Output = Token<UnifiedNodeDeque<Data>>

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<Data: Debug> Node for UnifiedNodeDeque<Data>

type Base = UnifiedNodeDeque<Data>

The ‘base node’ used in the arena.

type Token = Token<UnifiedNodeDeque<Data>>

The token associated with this type of node.

type Data = Data

The custom data associated with this node.

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

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

type DataRefMut<'data> = &'data mut Data 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

where Self: Sized,

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) -> &Self::Data

Returns a reference to the data associated with this node.

fn data_mut(&mut self) -> &mut Self::Data

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<Data: Debug> PartialEq for UnifiedNodeDeque<Data>

fn eq(&self, other: &Self) -> 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<Data: Debug> Eq for UnifiedNodeDeque<Data>