Enum trees::rc::RcNode

pub enum RcNode<T> {
    Scattered(ScatteredRcNode<T>),
    Piled(PiledRcNode<T>),
}

Reference-counting node.

Variants

Scattered(ScatteredRcNode<T>)

Piled(PiledRcNode<T>)

Implementations

impl<T> RcNode<T>

pub fn is_root(&self) -> bool

Checks if it is a root node.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0)/tr(1) );
assert!( root.is_root() );
assert!( !root.front().unwrap().is_root() );

pub fn data(&self) -> Ref<'_, T>

Dynamically borrows the node's data.

pub fn data_mut(&self) -> RefMut<'_, T>

Mutably borrows the node's data.

pub unsafe fn node(&self) -> Ref<'_, Node<T>>

Obtains a node reference

pub unsafe fn node_mut(&self) -> RefMut<'_, Node<T>>

Obtains a mutable node reference

pub fn has_no_child(&self) -> bool

Returns true if this Node has no child node, otherwise false.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0)/tr(1) );
assert!( !root.has_no_child() );
assert!( root.front().unwrap().has_no_child() );

pub fn degree(&self) -> usize

Returns the number of subtrees.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0, (1,2,3), (4,5,6), )));
assert_eq!( root.degree(), 2 );

pub fn node_count(&self) -> usize

Returns the number of all subnodes, including itself.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0, (1,2,3), (4,5,6), )));
assert_eq!( root.node_count(), 7 );

pub fn front(&self) -> Option<RcNode<T>>

Returns the first child of the tree, or None if it is empty.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0)/tr(1)/tr(2) );
assert_eq!( root.front(), Some( RcNode::from( tr(1) )));

pub fn back(&self) -> Option<RcNode<T>>

Returns the last child of the tree, or None if it is empty.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0)/tr(1)/tr(2) );
assert_eq!( root.back(), Some( RcNode::from( tr(2) )));

pub fn parent(&self) -> Option<RcNode<T>>

Returns the parent node of this node, or None if it is the root node.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0)/tr(1) );
assert_eq!( root.parent(), None );
let tr_1 = root.front().unwrap();
assert_eq!( tr_1.parent(), Some( root ));

pub fn push_front(&self, tree: Tree<T>)

Adds the tree as the first child.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::new(0) );
root.push_front( Tree::new(1) );
assert_eq!( root.to_string(), "0( 1 )" );
root.push_front( Tree::new(2) );
assert_eq!( root.to_string(), "0( 2 1 )" );

pub fn push_back(&self, tree: Tree<T>)

Adds the tree as the last child.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::new(0) );
root.push_back( Tree::new(1) );
assert_eq!( root.to_string(), "0( 1 )" );
root.push_back( Tree::new(2) );
assert_eq!( root.to_string(), "0( 1 2 )" );

pub fn pop_front(&self) -> Option<RcNode<T>>

Removes and return the first child.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0,1,2 )));
let front = root.pop_front().unwrap();
assert_eq!( front, RcNode::from( Tree::new(1) ));
assert_eq!( root.to_string(), "0( 2 )" );
let front = root.pop_front().unwrap();
assert_eq!( front, RcNode::from( Tree::new(2) ));
assert_eq!( root.to_string(), "0" );

pub fn pop_back(&self) -> Option<RcNode<T>>

Removes and return the last child.

Examples

use trees::{RcNode, Tree};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0,1,2 )));
let back = root.pop_back().unwrap();
assert_eq!( back, RcNode::from( Tree::new(2) ));
assert_eq!( root.to_string(), "0( 1 )" );
let back = root.pop_back().unwrap();
assert_eq!( back, RcNode::from( Tree::new(1) ));
assert_eq!( root.to_string(), "0" );

pub fn prepend(&self, forest: Forest<T>)

Adds all the forest's trees at front of children list.

Examples

use trees::{Forest, RcNode, Tree, tr};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0, 1, 2 )));
let forest = Forest::<i32>::from_tuple(( 3, 4 ));
root.prepend( forest );
assert_eq!( root.to_string(), "0( 3 4 1 2 )" );

pub fn append(&self, forest: Forest<T>)

Adds all the forest's trees at back of children list.

Examples

use trees::{Forest, RcNode, Tree, tr};

let root = RcNode::from( Tree::<i32>::from_tuple(( 0, 1, 2 )));
let forest = Forest::<i32>::from_tuple(( 3, 4 ));
root.append( forest );
assert_eq!( root.to_string(), "0( 1 2 3 4 )" );

pub fn insert_prev_sib(&self, sib: Tree<T>)

Inserts sib tree before self. The newly inserted node will not be iterated over by the currently running iterator.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0) /tr(1)/tr(2) );
for sub in root.iter_rc() { sub.insert_prev_sib( tr(3) ); }
assert_eq!( root.to_string(), "0( 3 1 3 2 )" );

pub fn insert_next_sib(&self, sib: Tree<T>)

Inserts sib tree after self. The newly inserted node will not be iterated over by the currently running iterator.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0) /tr(1)/tr(2) );
for sub in root.iter_rc() { sub.insert_next_sib( tr(3) ); }
assert_eq!( root.to_string(), "0( 1 3 2 3 )" );

pub fn detach(&self)

The subtree departs from its parent and becomes an indepent Tree.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0) /tr(1)/tr(2)/tr(3) );
for sub in root.iter_rc() { sub.detach(); }
assert!( root.has_no_child() );

pub fn iter_rc(&self) -> IterRc<T>

Provides a forward iterator over child Nodes, with shared ownership.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0) );
assert_eq!( root.iter_rc().next(), None );

let root = RcNode::from( tr(0) /tr(1)/tr(2) );
let mut iter = root.iter_rc();
assert_eq!( iter.next(), Some( RcNode::from( tr(1) )));
assert_eq!( iter.next(), Some( RcNode::from( tr(2) )));
assert_eq!( iter.next(), None );

pub fn downgrade(&self) -> WeakNode<T>

Creates a new weak pointer to this node.

pub unsafe fn into_tree(self) -> Tree<T>

Converts to a tree which disables reference-counting.

Panics

Only root node could be converted, otherwise it panics.

Examples

use trees::{RcNode, Tree, tr};

let root = RcNode::from( tr(0) /( tr(1)/tr(2) ));
let tree = unsafe{ root.into_tree() };
assert_eq!( tree, tr(0) /( tr(1)/tr(2) ));

let root = RcNode::from( Tree::<i32>::from_tuple(( 0, (1, 2), )));
let tree = unsafe{ root.into_tree() };
assert_eq!( tree, tr(0) /( tr(1)/tr(2) ));

impl<T: Clone> RcNode<T>

pub fn deep_clone(&self) -> Tree<T>

Clones the node deeply and creates a new tree.

Examples

use trees::{RcNode, tr};

let root = RcNode::from( tr(0) /( tr(1)/tr(2) ));
let new_tree = root.front().unwrap().deep_clone();
assert_eq!( new_tree, tr(1) /tr(2) );

Trait Implementations

impl<T> Clone for RcNode<T>

fn clone(&self) -> RcNode<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for RcNode<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for RcNode<T>

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

Formats the value using the given formatter.

impl<T> Drop for RcNode<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: Eq> Eq for RcNode<T>

impl<T> Extend<Tree<T>> for RcNode<T>

fn extend<I: IntoIterator<Item = Tree<T>>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

pub fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

pub fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T> From<Tree<T>> for RcNode<T>

fn from(tree: Tree<T>) -> Self

Performs the conversion.

impl<T: Hash> Hash for RcNode<T>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for RcNode<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq<RcNode<T>> for RcNode<T>

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

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

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

This method tests for !=.

impl<T: PartialOrd> PartialOrd<RcNode<T>> for RcNode<T>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.