Struct FlangedTree

pub struct FlangedTree<TD, A>
where
    TD: TreeData,
{ /* private fields */ }

Implementations

impl<TD, A> FlangedTree<TD, A>

where TD: TreeData,

pub fn new(base: TD, data: Vec<A>) -> Self

pub fn replace_map_flange<'a, B, F>(&'a self, mapf: F) -> FlangedTree<TD, B>

where F: Fn(<FlangedTree<TD, A> as Tree<'a>>::Node) -> B,

pub fn get_flange(&self, index: usize) -> &A

pub fn get_flange_mut(&mut self, index: usize) -> &mut A

Trait Implementations

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

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

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

The type of the trees nodes

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

The type of the subtree, returned by root()

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

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.

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.