Struct generational_arena_tree::split::BranchDeque

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

Available on crate features deque and split only.

Trait Implementations

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

where BranchData: Debug, LeafData: Debug,

type ChildrenIter<'branch> = Copied<Iter<'branch, <<BranchDeque<BranchData, LeafData> as Node>::Base as Node>::Token>> 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<SplitNodeRepresentation<BranchData, LeafData>>

Removes this branch node’s first child.

fn pop_back( token: Self::Token, arena: &mut Arena<Self::Base> ) -> Option<SplitNodeRepresentation<BranchData, LeafData>>

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.

impl<BranchData, LeafData> BranchNodeDeque for BranchDeque<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

fn len(&self) -> usize

Returns the number of children this branch node has.

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

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

fn remove( token: Self::Token, arena: &mut Arena<Self::Base>, index: usize ) -> SplitNodeRepresentation<BranchData, LeafData>

Removes the child at the given index.

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

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<BranchData: Debug + Debug, LeafData: Debug + Debug> Debug for BranchDeque<BranchData, LeafData>

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

Formats the value using the given formatter.

impl<BranchData, LeafData> Hash for BranchDeque<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> Index<usize> for BranchDeque<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

type Output = <<BranchDeque<BranchData, LeafData> as Node>::Base as Node>::Token

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

where BranchData: Debug, LeafData: Debug,

type Base = SplitNodeDeque<BranchData, LeafData>

The ‘base node’ used in the arena.

type Token = Token<BranchDeque<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 BranchDeque<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 SplitNodeDeque<BranchData, LeafData>> for &'node BranchDeque<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

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

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<'node, BranchData, LeafData> TryFrom<&'node mut SplitNodeDeque<BranchData, LeafData>> for &'node mut BranchDeque<BranchData, LeafData>

where BranchData: Debug, LeafData: Debug,

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

The type returned in the event of a conversion error.

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

Performs the conversion.

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

where BranchData: Debug, LeafData: Debug,