Trait Tree

pub trait Tree<'a>: Sized
where
    Self: 'a,
    &'a Self: TreeData<Node = Self::Node>,
{
    type Node;
    type SubtreeType: Subtree<Node = Self::Node>;

    // Required methods
    fn at_pos(&'a self, index: usize) -> Self::SubtreeType;
    fn get_nav(&self) -> &Navigator;

    // Provided methods
    fn root(&'a self) -> Self::SubtreeType { ... }
    fn node_count(&'a self) -> usize { ... }
    fn map<B, M>(&'a self, m: M) -> MappedTree<Self::Node, B, M, &'a Self>
       where M: Fn(usize, Self::Node) -> B { ... }
    fn flange<B>(&'a self, data: Vec<B>) -> FlangedTree<&'a Self, B> { ... }
    fn flange_map<B, F>(&'a self, mapf: F) -> FlangedTree<&'a Self, B>
       where B: 'a + Clone,
             F: Fn(Self::Node) -> B { ... }
    fn for_each<F>(&'a self, f: F)
       where F: FnMut(Self::SubtreeType) { ... }
    fn depth_first_flange<B, F>(&'a self, mapf: F) -> FlangedTree<&'a Self, B>
       where B: 'a + Default + Clone,
             F: Fn(Self::Node, Vec<&B>) -> B { ... }
}

Trait for everything that can be handled as a tree.

Required Associated Types

type Node

The type of the trees nodes

type SubtreeType: Subtree<Node = Self::Node>

The type of the subtree, returned by root()

Required Methods

fn at_pos(&'a self, index: usize) -> Self::SubtreeType

Direct access to a node in the tree via its position in the flat map

fn get_nav(&self) -> &Navigator

Direct access to the Navigator storing the neighboring information of the tree

Provided Methods

fn root(&'a self) -> Self::SubtreeType

The root node of the tree.

fn node_count(&'a self) -> usize

The number of nodes in the tree.

fn map<B, M>(&'a self, m: M) -> MappedTree<Self::Node, B, M, &'a Self>

where M: Fn(usize, Self::Node) -> B,

Create a new tree using a function to map from the nodes of this tree. The map function can also include external data sources.

Example

use flange_flat_tree::{Builder, Tree, Subtree};

let mut builder = Builder::with_capacity(2);
builder.start_element("one");
builder.start_end_element("two");
builder.end_element();
let tree = builder.build();

struct FlangedNode<'a> {
    pub name: &'a str,
    pub value: u32, // we don't use a reference for u32, because copying the value itself is fine
}

// The data we are going to flange
let data: Vec<u32> = vec![1,2];

let tree_with_values = tree.map(
    |i,v| FlangedNode {
        name: v,
        value: data[i],
    }
);

assert_eq!(tree_with_values.root().value().name, "one");
assert_eq!(tree_with_values.root().value().value, 1);

fn flange<B>(&'a self, data: Vec<B>) -> FlangedTree<&'a Self, B>

Flange data to the nodes. A new tree is created, that references the old tree and whos Node type is a typle with a reference to the old data and a reference to the new data from the inserted data vector.

fn flange_map<B, F>(&'a self, mapf: F) -> FlangedTree<&'a Self, B>

where B: 'a + Clone, F: Fn(Self::Node) -> B,

Use flange, but create the data using the mapf function

fn for_each<F>(&'a self, f: F)

where F: FnMut(Self::SubtreeType),

fn depth_first_flange<B, F>(&'a self, mapf: F) -> FlangedTree<&'a Self, B>

where B: 'a + Default + Clone, F: Fn(Self::Node, Vec<&B>) -> B,

Flange data to the nodes using a map function in a depth first order.

This means the children are available (already created) when a node is created and can be used to calculate the nodes value.

Example

use flange_flat_tree::{Builder, Tree, Subtree};

let mut builder = Builder::with_capacity(2);
builder.start_element("one");
builder.start_element("two");
builder.start_end_element("three");
builder.start_end_element("four");
builder.end_element();
builder.end_element();
let tree = builder.build();

// The data we are going to flange
let data: Vec<u32> = vec![1,2];

let tree_with_values = tree.depth_first_flange(
    |v, childs| {
        // Calculate the total number of children
        childs.iter().fold(childs.len(), |l,c| l+*c )
    }
);

assert_eq!(tree_with_values.root().value().1, &3);
assert_eq!(tree_with_values.root().children()[0].value(), (&"two", &2));

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, A> Tree<'a> for VecTree<A>

where A: 'a,

type Node = &'a A

type SubtreeType = SubtreeImpl<&'a VecTree<A>>

impl<'a, TD, A> Tree<'a> for FlangedTree<TD, A>

where A: 'a, TD: TreeData + 'a,

type Node = (<TD as TreeData>::Node, &'a A)

type SubtreeType = SubtreeImpl<&'a FlangedTree<TD, A>>