Struct Tree

pub struct Tree<T> { /* private fields */ }

A tree structure containing Nodes.

Implementations

impl<T> Tree<T>

pub fn new() -> Tree<T>

Creates a new Tree with a capacity of 0.

use slab_tree::tree::Tree;

let tree: Tree<i32> = Tree::new();

pub fn set_root(&mut self, root: T) -> NodeId

Sets the “root” of the Tree to be root.

If there is already a “root” node in the Tree, that node is shifted down and the new one takes its place.

use slab_tree::tree::Tree;

let mut tree = Tree::new();

let root_id = tree.set_root(1);

assert_eq!(tree.root_id().unwrap(), root_id);

pub fn capacity(&self) -> usize

Returns the Tree’s current capacity. Capacity is defined as the number of times new Nodes can be added to the Tree before it must allocate more memory.

use slab_tree::tree::Tree;

let tree: Tree<i32> = Tree::new();

assert_eq!(tree.capacity(), 0);

pub fn root_id(&self) -> Option<NodeId>

Returns the NodeId of the root node of the Tree.

use slab_tree::tree::Tree;

let mut tree = Tree::new();
tree.set_root(1);

let root_id = tree.root_id().expect("root doesn't exist?");

assert_eq!(tree.get(root_id).unwrap().data(), &1);

Examples found in repository

examples/basic.rs (line 15)

fn main() {
    //      "hello"
    //        / \
    // "world"   "trees"
    //              |
    //            "are"
    //              |
    //            "cool"

    let mut tree = TreeBuilder::new().with_root("hello").build();
    let root_id = tree.root_id().expect("root doesn't exist?");
    let mut hello = tree.get_mut(root_id).unwrap();

    hello.append("world");
    hello.append("trees").append("are").append("cool");
}

pub fn root(&self) -> Option<NodeRef<'_, T>>

Returns a NodeRef pointing to the root Node of the Tree.

use slab_tree::tree::Tree;

let mut tree = Tree::new();
tree.set_root(1);

let root = tree.root().expect("root doesn't exist?");

assert_eq!(root.data(), &1);

pub fn root_mut(&mut self) -> Option<NodeMut<'_, T>>

Returns a NodeMut pointing to the root Node of the Tree.

use slab_tree::tree::Tree;

let mut tree = Tree::new();
tree.set_root(1);

let mut root = tree.root_mut().expect("root doesn't exist?");
assert_eq!(root.data(), &mut 1);

*root.data() = 2;
assert_eq!(root.data(), &mut 2);

Examples found in repository

examples/formatted.rs (line 7)

fn main() {
    let mut tree = TreeBuilder::new().with_root(0).build();
    let mut root = tree.root_mut().unwrap();
    {
        let mut one = root.append(1);
        let mut two = one.append(2);
        two.append(3);
        two.append(4);
    }
    {
        let mut five = root.append(5);
        five.append(6).append(7);
        five.append(8);
    }
    root.append(9);

    let mut s = String::new();
    // 0
    // ├── 1
    // │   └── 2
    // │       ├── 3
    // │       └── 4
    // ├── 5
    // │   ├── 6
    // │   │   └── 7
    // │   └── 8
    // └── 9
    tree.write_formatted(&mut s).unwrap();
    print!("{}", s);
}

pub fn get(&self, node_id: NodeId) -> Option<NodeRef<'_, T>>

Returns the NodeRef pointing to the Node that the given NodeId identifies. If the NodeId in question points to nothing (or belongs to a different Tree) a None-value will be returned; otherwise, a Some-value will be returned.

use slab_tree::tree::Tree;

let mut tree = Tree::new();
tree.set_root(1);
let root_id = tree.root_id().expect("root doesn't exist?");

let root = tree.get(root_id);
assert!(root.is_some());

let root = root.unwrap();
assert_eq!(root.data(), &1);

pub fn get_mut(&mut self, node_id: NodeId) -> Option<NodeMut<'_, T>>

Returns the NodeMut pointing to the Node that the given NodeId identifies. If the NodeId in question points to nothing (or belongs to a different Tree) a None-value will be returned; otherwise, a Some-value will be returned.

use slab_tree::tree::Tree;

let mut tree = Tree::new();
tree.set_root(1);
let root_id = tree.root_id().expect("root doesn't exist?");

let root = tree.get_mut(root_id);
assert!(root.is_some());

let mut root = root.unwrap();

*root.data() = 2;
assert_eq!(root.data(), &mut 2);

Examples found in repository

examples/basic.rs (line 16)

fn main() {
    //      "hello"
    //        / \
    // "world"   "trees"
    //              |
    //            "are"
    //              |
    //            "cool"

    let mut tree = TreeBuilder::new().with_root("hello").build();
    let root_id = tree.root_id().expect("root doesn't exist?");
    let mut hello = tree.get_mut(root_id).unwrap();

    hello.append("world");
    hello.append("trees").append("are").append("cool");
}

pub fn remove(&mut self, node_id: NodeId, behavior: RemoveBehavior) -> Option<T>

Remove a Node by its NodeId and return the data that it contained. Returns a Some-value if the Node exists; returns a None-value otherwise.

Children of the removed Node can either be dropped with DropChildren or orphaned with OrphanChildren.

use slab_tree::tree::TreeBuilder;
use slab_tree::behaviors::RemoveBehavior::*;

let mut tree = TreeBuilder::new().with_root(1).build();
let two_id = {
    let mut root = tree.root_mut().expect("root doesn't exist?");
    let two_id = root.append(2).node_id();
    root.append(3);
    two_id
};

let two = tree.remove(two_id, DropChildren);

assert!(two.is_some());
assert_eq!(two.unwrap(), 2);

let root = tree.root().expect("root doesn't exist?");
assert!(root.first_child().is_some());
assert_eq!(root.first_child().unwrap().data(), &mut 3);

assert!(root.last_child().is_some());
assert_eq!(root.last_child().unwrap().data(), &mut 3);

impl<T: Debug> Tree<T>

pub fn write_formatted<W: Write>(&self, w: &mut W) -> Result

Write formatted tree representation and nodes with debug formatting.

Example:

use slab_tree::tree::TreeBuilder;

let mut tree = TreeBuilder::new().with_root(0).build();
let mut root = tree.root_mut().unwrap();
root.append(1)
    .append(2);
root.append(3);
let mut s = String::new();
tree.write_formatted(&mut s).unwrap();
assert_eq!(&s, "\
0
├── 1
│   └── 2
└── 3
");

Writes nothing if the tree is empty.

use slab_tree::tree::TreeBuilder;

let tree = TreeBuilder::<i32>::new().build();
let mut s = String::new();
tree.write_formatted(&mut s).unwrap();
assert_eq!(&s, "");

Examples found in repository

examples/formatted.rs (line 32)

fn main() {
    let mut tree = TreeBuilder::new().with_root(0).build();
    let mut root = tree.root_mut().unwrap();
    {
        let mut one = root.append(1);
        let mut two = one.append(2);
        two.append(3);
        two.append(4);
    }
    {
        let mut five = root.append(5);
        five.append(6).append(7);
        five.append(8);
    }
    root.append(9);

    let mut s = String::new();
    // 0
    // ├── 1
    // │   └── 2
    // │       ├── 3
    // │       └── 4
    // ├── 5
    // │   ├── 6
    // │   │   └── 7
    // │   └── 8
    // └── 9
    tree.write_formatted(&mut s).unwrap();
    print!("{}", s);
}

Trait Implementations

impl<T: Debug> Debug for Tree<T>

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

Formats the value using the given formatter.

impl<T> Default for Tree<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: PartialEq> PartialEq for Tree<T>

fn eq(&self, other: &Tree<T>) -> 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<T> StructuralPartialEq for Tree<T>