Struct trees::potted::node::Node

pub struct Node<T> {
    pub data: T,
    // some fields omitted
}

Fields

data: T

Implementations

impl<T> Node<T>

pub fn is_leaf(&self) -> bool

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

Examples

use trees::potted::{Tree,Node,TreeData,TupleTree};

let mut tree = Tree::<_>::from(( 1, ));
let root: &mut Node<_> = tree.root_mut();
assert!( root.is_leaf() );

root.append_tr(( 2, ));
assert!( !root.is_leaf() );

pub fn data(&self) -> &T

👎 Deprecated since 0.2.1:

please use data field instead

pub fn data_mut(&mut self) -> &mut T

👎 Deprecated since 0.2.1:

please use data field instead

pub fn set_data(&mut self, data: T)

👎 Deprecated since 0.2.1:

please use data field instead

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

Returns reference of parent node if exists, otherwise None.

Examples

use trees::potted::{Tree,Node,TreeData,TupleTree};

let mut tree = Tree::<_>::from(( 1, 2 ));
let root  : &Node<_> = tree.root();
let child : &Node<_> = root.iter().next().unwrap();
assert_eq!( root.parent(),  None );
assert_eq!( child.parent(), Some( root ));

pub fn nth_child(&self, n: usize) -> Option<&Self>

Returns the immutable reference of n-th child node if exists, otherwise None. Note that it is zero-based index.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let tree: Tree<_> = ( "a", "b", "c", "d", "e" ).into();
assert_eq!( tree.root().nth_child(2).unwrap().data, "d" );

pub fn nth_child_mut(&mut self, n: usize) -> Option<&mut Self>

Returns the mutable reference of n-th child node if exists, otherwise None. Note that it is zero-based index.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( "a", "b", "c", "d", "e" ).into();
tree.root_mut().nth_child_mut(2).unwrap().data = "D";
assert_eq!( tree.to_string(), "a( b c D e )" );

pub fn iter<'a, 's: 'a>(&'s self) -> Iter<'a, T>

Provides a forward iterator over child nodes

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let tree: Tree<_> = ( "a","b","c","d" ).into();
let mut iter = tree.root().iter();
assert_eq!( iter.next().unwrap().data, "b" );
assert_eq!( iter.next().unwrap().data, "c" );
assert_eq!( iter.next().unwrap().data, "d" );
assert_eq!( iter.next(), None );
assert_eq!( iter.next(), None );

pub fn iter_mut<'a, 's: 'a>(&'s mut self) -> IterMut<'a, T>

Provides a forward iterator over child nodes with mutable references.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( 0, 1, 2, 3 ).into();
for child in tree.root_mut().iter_mut() {
    child.data *= 10;
}
assert_eq!( tree.root().to_string(), "0( 10 20 30 )" );

pub fn bfs(&self) -> BfsTree<Splitted<Iter<'_, T>>>

Provides a forward iterator in a breadth-first manner

Examples

use trees::{bfs,Size};
use trees::potted::Tree;

let tree: Tree<_> = (0, (1,2,3), (4,5,6) ).into();
let visits = tree.root().bfs().iter.collect::<Vec<_>>();
assert_eq!( visits, vec![
    bfs::Visit{ data: &0, size: Size{ degree: 2, node_cnt: 7 }},
    bfs::Visit{ data: &1, size: Size{ degree: 2, node_cnt: 3 }},
    bfs::Visit{ data: &4, size: Size{ degree: 2, node_cnt: 3 }},
    bfs::Visit{ data: &2, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &3, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &5, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &6, size: Size{ degree: 0, node_cnt: 1 }},
]);

pub fn prepend_tr<Tr>(&mut self, tuple: Tr) where
    Tr: TupleTree<Data = T>, 

Add the tuple tree as the first child.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( "a", "b", "c" ).into();
tree.root_mut().prepend_tr(( "d", "e", "f" ));
assert_eq!( tree.root().to_string(), "a( d( e f ) b c )" );

pub fn append_tr<Tr>(&mut self, tuple: Tr) where
    Tr: TupleTree<Data = T>, 

Add the tuple tree as the last child.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( "a", "b", "c" ).into();
tree.root_mut().append_tr(( "d", "e", "f" ));
assert_eq!( tree.root().to_string(), "a( b c d( e f ) )" );

pub fn prepend_fr<Fr>(&mut self, tuple: Fr) where
    Fr: TupleForest<Data = T>, 

Add the tuple forest as the first-n children.

Examples

use trees::potted::{Tree,TreeData,TupleTree,fr};

let mut tree: Tree<_> = ( "a", "b", "c" ).into();
tree.root_mut().prepend_fr(( fr(), "d", "e", "f" ));
assert_eq!( tree.root().to_string(), "a( d e f b c )" );

pub fn append_fr<Fr>(&mut self, tuple: Fr) where
    Fr: TupleForest<Data = T>, 

Add the tuple forest as the last-n children.

Examples

use trees::potted::{Tree,TreeData,TupleTree,fr};

let mut tree: Tree<_> = ( "a", "b", "c" ).into();
tree.root_mut().append_fr(( fr(), "d", "e", "f" ));
assert_eq!( tree.root().to_string(), "a( b c d e f )" );

pub fn insert_tr<Tuple>(&mut self, nth: usize, tuple: Tuple) where
    Tuple: TupleTree<Data = T>, 

Insert the tuple tree as the n-th child. Note that it is zero-based index.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( "a", "b", "c", "d", "e" ).into();
tree.root_mut().insert_tr( 2, ("f",) );
assert_eq!( tree.root().to_string(), "a( b c f d e )" );

pub fn drop_front(&mut self)

Drop the first child.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( 1, 2, 3, 4 ).into();
tree.root_mut().drop_front();
assert_eq!( tree.root().to_string(), "1( 3 4 )" );

pub fn drop_back(&mut self)

Drop the last child.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( 1, 2, 3, 4 ).into();
tree.root_mut().drop_back();
assert_eq!( tree.root().to_string(), "1( 2 3 )" );

pub fn drop_nth(&mut self, nth: usize)

Drop the n-th child.

Examples

use trees::potted::{Tree,TreeData,TupleTree};

let mut tree: Tree<_> = ( "a", "b", "c", "d", "e" ).into();
tree.root_mut().drop_nth( 2 );
assert_eq!( tree.root().to_string(), "a( b c e )" );

pub fn prepend_bfs<Iter>(&mut self, bfs: Bfs<Iter>) where
    Iter: Iterator<Item = Visit<T>>, 

Add tree(s) from a bfs iterator as the first child(ren).

Examples

use trees::linked::fully::tr;
use trees::linked::singly::tr as t;
use trees::potted::{Tree,TreeData,TupleTree};

let mut potted: Tree<_> = ( 0, (1,2), (3,4) ).into();

let linked = tr(5) /tr(6) /tr(7);
potted.root_mut().nth_child_mut(0).unwrap().prepend_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 5( 6 7 ) 2 ) 3( 4 ) )" );

let linked = t(8) /t(9) /t(10);
potted.root_mut().nth_child_mut(1).unwrap().prepend_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 5( 6 7 ) 2 ) 3( 8( 9 10 ) 4 ) )" );

Examples

use trees::linked::fully::tr;
use trees::linked::singly::tr as t;
use trees::potted::{Tree,TreeData,TupleTree};

let mut potted: Tree<_> = ( 0, (1,2), (3,4) ).into();

let linked = tr(5) -tr(6) -tr(7);
potted.root_mut().nth_child_mut(0).unwrap().prepend_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 5 6 7 2 ) 3( 4 ) )" );

//let linked = t(8) /t(9) /t(10);
//potted.root_mut().nth_child_mut(1).unwrap().prepend_bfs( linked.into_bfs() );
//assert_eq!( potted.root().to_string(), "0( 1( 5 6 7 2 ) 3( 8 9 10 4 ) )" );

pub fn append_bfs<Iter>(&mut self, bfs: Bfs<Iter>) where
    Iter: Iterator<Item = Visit<T>>, 

Add tree(s) from a bfs iterator as the last child(ren).

Examples

use trees::linked::fully::tr;
use trees::linked::singly::tr as t;
use trees::potted::{Tree,TreeData,TupleTree};

let mut potted: Tree<_> = ( 0, (1,2), (3,4) ).into();

let linked = tr(5) /tr(6) /tr(7);
potted.root_mut().nth_child_mut(0).unwrap().append_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 2 5( 6 7 ) ) 3( 4 ) )" );

let linked = t(8) /t(9) /t(10);
potted.root_mut().nth_child_mut(1).unwrap().append_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 2 5( 6 7 ) ) 3( 4 8( 9 10 ) ) )" );

Examples

use trees::linked::fully::tr;
use trees::linked::singly::tr as t;
use trees::potted::{Tree,TreeData,TupleTree};

let mut potted: Tree<_> = ( 0, (1,2), (3,4) ).into();

let linked = tr(5) -tr(6) -tr(7);
potted.root_mut().nth_child_mut(0).unwrap().append_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 2 5 6 7 ) 3( 4 ) )" );

let linked = t(8) -t(9) -t(10);
potted.root_mut().nth_child_mut(1).unwrap().append_bfs( linked.into_bfs().wrap() );
assert_eq!( potted.root().to_string(), "0( 1( 2 5 6 7 ) 3( 4 8 9 10 ) )" );

pub fn bfs_mut(&mut self) -> BfsTree<Splitted<IterMut<'_, T>>>

Provides a forward iterator with mutable references in a breadth-first manner

Examples

use trees::{bfs,Size};
use trees::potted::Tree;

let mut tree: Tree<_> = (0, (1,2,3), (4,5,6) ).into();
let visits = tree.root_mut().bfs_mut().iter.collect::<Vec<_>>();
assert_eq!( visits, vec![
    bfs::Visit{ data: &mut 0, size: Size{ degree: 2, node_cnt: 7 }},
    bfs::Visit{ data: &mut 1, size: Size{ degree: 2, node_cnt: 3 }},
    bfs::Visit{ data: &mut 4, size: Size{ degree: 2, node_cnt: 3 }},
    bfs::Visit{ data: &mut 2, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &mut 3, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &mut 5, size: Size{ degree: 0, node_cnt: 1 }},
    bfs::Visit{ data: &mut 6, size: Size{ degree: 0, node_cnt: 1 }},
]);

Trait Implementations

impl<T> Borrow<Node<T>> for Tree<T>

fn borrow(&self) -> &Node<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<Node<T>> for Tree<T>

fn borrow_mut(&mut self) -> &mut Node<T>

Mutably borrows from an owned value.

impl<T: Debug> Debug for Node<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Node<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Node<T>

impl<T: Hash> Hash for Node<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> Indexed for Node<T>

fn null() -> usize

Defines which index value is for null. If the underlying storage for index is smaller than usize’s size, the library user should override this method and pick a smaller value, e.g !0_u32 for index stored in u32. Note that it is for convenience only, and the library will not do any index check against null().

unsafe fn get_index(&self) -> usize

Gets the element’s index in the pool.

unsafe fn set_index(&mut self, index: usize)

Sets the element’s index in the pool. The library user is not expected to call it directly.

pub fn chunk_len() -> ChunkLen

Sets the underlying chunk size. The default is 256, and can be overrided by those values defined in ChunkLen.

pub fn pool(&self) -> &Pool<Self>

Obtains reference of its pool.

pub unsafe fn pool_mut(&self) -> &mut Pool<Self>

Obtains mutable reference of its pool.

pub fn pool_non_null(&self) -> NonNull<Pool<Self>>

Obtains non null pointer of its pool.

pub fn pool_push(&self, value: Self)

Appends an element to the back of its pool.

pub unsafe fn pool_write(&self, index: usize, value: Self)

Overwrites a new value into its pool at given index without reading or dropping the old value.

pub fn pool_reserve(&self, additional: usize)

Reserves capacity for at least additional more elements to be inserted in the given Pool. The collection may reserve more space because the increasing size must be multiple of underlying chunk_len(). After calling reserve, capacity will be greater than or equal to self.pool().new_index() + additional. Does nothing if capacity is already sufficient.

impl<'a, T: 'a> IntoIterator for &'a Node<T>

type Item = Self

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: 'a> IntoIterator for &'a mut Node<T>

type Item = Self

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for Node<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<Node<T>> for Node<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<Node<T>> for Node<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.

impl<'a, T: 'a> Split for &'a Node<T>

type Item = &'a T

type Iter = Iter<'a, T>

fn split(self) -> (&'a T, Iter<'a, T>, u32)

impl<'a, T: 'a> Split for &'a mut Node<T>

type Item = &'a mut T

type Iter = IterMut<'a, T>

fn split(self) -> (&'a mut T, IterMut<'a, T>, u32)