tree  release 2.0
Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Private Member Functions | Private Attributes | List of all members
tree< T, tree_node_allocator > Class Template Reference

#include <tree.hh>

Classes

class  breadth_first_queued_iterator
 Breadth-first iterator, using a queue. More...
 
class  compare_nodes
 Comparator class for two nodes of a tree (used for sorting and searching). More...
 
class  fixed_depth_iterator
 Iterator which traverses only the nodes at a given depth from the root. More...
 
class  iterator_base
 Base class for iterators, only pointers stored, no traversal logic. More...
 
class  iterator_base_less
 Comparator class for iterators (compares pointer values; why doesn't this work automatically?) More...
 
class  leaf_iterator
 Iterator which traverses only the leaves. More...
 
class  post_order_iterator
 Depth-first iterator, first accessing the children, then the node itself. More...
 
class  pre_order_iterator
 Depth-first iterator, first accessing the node, then its children. More...
 
class  sibling_iterator
 Iterator which traverses only the nodes which are siblings of each other. More...
 

Public Types

typedef T value_type
 Value of the data stored at a node. More...
 
typedef pre_order_iterator iterator
 The default iterator types throughout the tree class. More...
 
typedef breadth_first_queued_iterator breadth_first_iterator
 

Public Member Functions

 tree ()
 
 tree (const T &)
 
 tree (const iterator_base &)
 
 tree (const tree< T, tree_node_allocator > &)
 
 tree (tree< T, tree_node_allocator > &&)
 
 ~tree ()
 
tree< T, tree_node_allocator > & operator= (const tree< T, tree_node_allocator > &)
 
tree< T, tree_node_allocator > & operator= (tree< T, tree_node_allocator > &&)
 
pre_order_iterator begin () const
 Return iterator to the beginning of the tree. More...
 
pre_order_iterator end () const
 Return iterator to the end of the tree. More...
 
post_order_iterator begin_post () const
 Return post-order iterator to the beginning of the tree. More...
 
post_order_iterator end_post () const
 Return post-order end iterator of the tree. More...
 
fixed_depth_iterator begin_fixed (const iterator_base &, unsigned int) const
 Return fixed-depth iterator to the first node at a given depth from the given iterator. More...
 
fixed_depth_iterator end_fixed (const iterator_base &, unsigned int) const
 Return fixed-depth end iterator. More...
 
breadth_first_queued_iterator begin_breadth_first () const
 Return breadth-first iterator to the first node at a given depth. More...
 
breadth_first_queued_iterator end_breadth_first () const
 Return breadth-first end iterator. More...
 
leaf_iterator begin_leaf () const
 Return leaf iterator to the first leaf of the tree. More...
 
leaf_iterator end_leaf () const
 Return leaf end iterator for entire tree. More...
 
leaf_iterator begin_leaf (const iterator_base &top) const
 Return leaf iterator to the first leaf of the subtree at the given node. More...
 
leaf_iterator end_leaf (const iterator_base &top) const
 Return leaf end iterator for the subtree at the given node. More...
 
template<typename iter >
iter next_at_same_depth (iter) const
 Return iterator to the next node at a given depth. More...
 
void clear ()
 Erase all nodes of the tree. More...
 
template<typename iter >
iter erase (iter)
 Erase element at position pointed to by iterator, return incremented iterator. More...
 
void erase_children (const iterator_base &)
 Erase all children of the node pointed to by iterator. More...
 
void erase_right_siblings (const iterator_base &)
 Erase all siblings to the right of the iterator. More...
 
void erase_left_siblings (const iterator_base &)
 Erase all siblings to the left of the iterator. More...
 
template<typename iter >
iter append_child (iter position)
 Insert empty node as last/first child of node pointed to by position. More...
 
template<typename iter >
iter prepend_child (iter position)
 
template<typename iter >
iter append_child (iter position, const T &x)
 Insert node as last/first child of node pointed to by position. More...
 
template<typename iter >
iter append_child (iter position, T &&x)
 
template<typename iter >
iter prepend_child (iter position, const T &x)
 
template<typename iter >
iter prepend_child (iter position, T &&x)
 
template<typename iter >
iter append_child (iter position, iter other_position)
 Append the node (plus its children) at other_position as last/first child of position. More...
 
template<typename iter >
iter prepend_child (iter position, iter other_position)
 
template<typename iter >
iter append_children (iter position, sibling_iterator from, sibling_iterator to)
 Append the nodes in the from-to range (plus their children) as last/first children of position. More...
 
template<typename iter >
iter prepend_children (iter position, sibling_iterator from, sibling_iterator to)
 
pre_order_iterator set_head (const T &x)
 Short-hand to insert topmost node in otherwise empty tree. More...
 
pre_order_iterator set_head (T &&x)
 
template<typename iter >
iter insert (iter position, const T &x)
 Insert node as previous sibling of node pointed to by position. More...
 
template<typename iter >
iter insert (iter position, T &&x)
 
sibling_iterator insert (sibling_iterator position, const T &x)
 Specialisation of previous member. More...
 
template<typename iter >
iter insert_subtree (iter position, const iterator_base &subtree)
 
template<typename iter >
iter insert_after (iter position, const T &x)
 Insert node as next sibling of node pointed to by position. More...
 
template<typename iter >
iter insert_after (iter position, T &&x)
 
template<typename iter >
iter insert_subtree_after (iter position, const iterator_base &subtree)
 Insert node (with children) pointed to by subtree as next sibling of node pointed to by position. More...
 
template<typename iter >
iter replace (iter position, const T &x)
 Replace node at 'position' with other node (keeping same children); 'position' becomes invalid. More...
 
template<typename iter >
iter replace (iter position, const iterator_base &from)
 Replace node at 'position' with subtree starting at 'from' (do not erase subtree at 'from'); see above. More...
 
sibling_iterator replace (sibling_iterator orig_begin, sibling_iterator orig_end, sibling_iterator new_begin, sibling_iterator new_end)
 Replace string of siblings (plus their children) with copy of a new string (with children); see above. More...
 
template<typename iter >
iter flatten (iter position)
 Move all children of node at 'position' to be siblings, returns position. More...
 
template<typename iter >
iter reparent (iter position, sibling_iterator begin, sibling_iterator end)
 Move nodes in range to be children of 'position'. More...
 
template<typename iter >
iter reparent (iter position, iter from)
 Move all child nodes of 'from' to be children of 'position'. More...
 
template<typename iter >
iter wrap (iter position, const T &x)
 Replace node with a new node, making the old node (plus subtree) a child of the new node. More...
 
template<typename iter >
iter wrap (iter from, iter to, const T &x)
 Replace the range of sibling nodes (plus subtrees), making these children of the new node. More...
 
template<typename iter >
iter move_after (iter target, iter source)
 Move 'source' node (plus its children) to become the next sibling of 'target'. More...
 
template<typename iter >
iter move_before (iter target, iter source)
 Move 'source' node (plus its children) to become the previous sibling of 'target'. More...
 
sibling_iterator move_before (sibling_iterator target, sibling_iterator source)
 
template<typename iter >
iter move_ontop (iter target, iter source)
 Move 'source' node (plus its children) to become the node at 'target' (erasing the node at 'target'). More...
 
tree move_out (iterator)
 Extract the subtree starting at the indicated node, removing it from the original tree. More...
 
template<typename iter >
iter move_in (iter, tree &)
 
template<typename iter >
iter move_in_below (iter, tree &)
 As above, but now make the tree a child of the indicated node. More...
 
template<typename iter >
iter move_in_as_nth_child (iter, size_t, tree &)
 As above, but now make the tree the nth child of the indicated node (if possible). More...
 
void merge (sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator, bool duplicate_leaves=false)
 Merge with other tree, creating new branches and leaves only if they are not already present. More...
 
void sort (sibling_iterator from, sibling_iterator to, bool deep=false)
 Sort (std::sort only moves values of nodes, this one moves children as well). More...
 
template<class StrictWeakOrdering >
void sort (sibling_iterator from, sibling_iterator to, StrictWeakOrdering comp, bool deep=false)
 
template<typename iter >
bool equal (const iter &one, const iter &two, const iter &three) const
 Compare two ranges of nodes (compares nodes as well as tree structure). More...
 
template<typename iter , class BinaryPredicate >
bool equal (const iter &one, const iter &two, const iter &three, BinaryPredicate) const
 
template<typename iter >
bool equal_subtree (const iter &one, const iter &two) const
 
template<typename iter , class BinaryPredicate >
bool equal_subtree (const iter &one, const iter &two, BinaryPredicate) const
 
tree subtree (sibling_iterator from, sibling_iterator to) const
 Extract a new tree formed by the range of siblings plus all their children. More...
 
void subtree (tree &, sibling_iterator from, sibling_iterator to) const
 
void swap (sibling_iterator it)
 Exchange the node (plus subtree) with its sibling node (do nothing if no sibling present). More...
 
void swap (iterator, iterator)
 
size_t size () const
 Count the total number of nodes. More...
 
size_t size (const iterator_base &) const
 Count the total number of nodes below the indicated node (plus one). More...
 
bool empty () const
 Check if tree is empty. More...
 
int max_depth () const
 Determine the maximal depth of the tree. An empty tree has max_depth=-1. More...
 
int max_depth (const iterator_base &) const
 Determine the maximal depth of the tree with top node at the given position. More...
 
unsigned int number_of_siblings (const iterator_base &) const
 Count the number of siblings (left and right) of node at iterator. Total nodes at this level is +1. More...
 
bool is_in_subtree (const iterator_base &position, const iterator_base &begin, const iterator_base &end) const
 Determine whether node at position is in the subtrees with root in the range. More...
 
bool is_valid (const iterator_base &) const
 Determine whether the iterator is an 'end' iterator and thus not actually pointing to a node. More...
 
iterator lowest_common_ancestor (const iterator_base &, const iterator_base &) const
 
unsigned int index (sibling_iterator it) const
 Determine the index of a node in the range of siblings to which it belongs. More...
 
sibling_iterator sibling (const iterator_base &position, unsigned int) const
 Return iterator to the sibling indicated by index. More...
 
void debug_verify_consistency () const
 

Static Public Member Functions

static sibling_iterator begin (const iterator_base &)
 Return sibling iterator to the first child of given node. More...
 
static sibling_iterator end (const iterator_base &)
 Return sibling end iterator for children of given node. More...
 
template<typename iter >
static iter parent (iter)
 Return iterator to the parent of a node. More...
 
template<typename iter >
static iter previous_sibling (iter)
 Return iterator to the previous sibling of a node. More...
 
template<typename iter >
static iter next_sibling (iter)
 Return iterator to the next sibling of a node. More...
 
static int depth (const iterator_base &)
 Compute the depth to the root or to a fixed other iterator. More...
 
static int depth (const iterator_base &, const iterator_base &)
 
static unsigned int number_of_children (const iterator_base &)
 Count the number of children of node at position. More...
 
static bool is_head (const iterator_base &)
 Determine whether the iterator is one of the 'head' nodes at the top level, i.e. has no parent. More...
 
static sibling_iterator child (const iterator_base &position, unsigned int)
 Inverse of 'index': return the n-th child of the node at position. More...
 

Public Attributes

tree_nodehead
 
tree_nodefeet
 

Protected Types

typedef tree_node_< T > tree_node
 

Private Member Functions

void head_initialise_ ()
 
void copy_ (const tree< T, tree_node_allocator > &other)
 

Private Attributes

tree_node_allocator alloc_
 

Member Typedef Documentation

template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
typedef breadth_first_queued_iterator tree< T, tree_node_allocator >::breadth_first_iterator
template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
typedef pre_order_iterator tree< T, tree_node_allocator >::iterator

The default iterator types throughout the tree class.

template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
typedef tree_node_<T> tree< T, tree_node_allocator >::tree_node
protected
template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
typedef T tree< T, tree_node_allocator >::value_type

Value of the data stored at a node.

Constructor & Destructor Documentation

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::tree ( )
template<class T, class tree_node_allocator >
tree< T, tree_node_allocator >::tree ( const T &  x)
template<class T, class tree_node_allocator >
tree< T, tree_node_allocator >::tree ( const iterator_base other)
template<class T, class tree_node_allocator>
tree< T, tree_node_allocator >::tree ( const tree< T, tree_node_allocator > &  other)
template<class T, class tree_node_allocator>
tree< T, tree_node_allocator >::tree ( tree< T, tree_node_allocator > &&  x)
template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::~tree ( )

Member Function Documentation

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::append_child ( iter  position)

Insert empty node as last/first child of node pointed to by position.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::append_child ( iter  position,
const T &  x 
)

Insert node as last/first child of node pointed to by position.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::append_child ( iter  position,
T &&  x 
)
template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::append_child ( iter  position,
iter  other_position 
)

Append the node (plus its children) at other_position as last/first child of position.

template<class T , class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::append_children ( iter  position,
sibling_iterator  from,
sibling_iterator  to 
)

Append the nodes in the from-to range (plus their children) as last/first children of position.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::pre_order_iterator tree< T, tree_node_allocator >::begin ( ) const
inline

Return iterator to the beginning of the tree.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::begin ( const iterator_base pos)
static

Return sibling iterator to the first child of given node.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::breadth_first_queued_iterator tree< T, tree_node_allocator >::begin_breadth_first ( ) const

Return breadth-first iterator to the first node at a given depth.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::fixed_depth_iterator tree< T, tree_node_allocator >::begin_fixed ( const iterator_base pos,
unsigned int  dp 
) const

Return fixed-depth iterator to the first node at a given depth from the given iterator.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::leaf_iterator tree< T, tree_node_allocator >::begin_leaf ( ) const

Return leaf iterator to the first leaf of the tree.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::leaf_iterator tree< T, tree_node_allocator >::begin_leaf ( const iterator_base top) const

Return leaf iterator to the first leaf of the subtree at the given node.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::post_order_iterator tree< T, tree_node_allocator >::begin_post ( ) const

Return post-order iterator to the beginning of the tree.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::child ( const iterator_base position,
unsigned int  num 
)
static

Inverse of 'index': return the n-th child of the node at position.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::clear ( )

Erase all nodes of the tree.

template<class T, class tree_node_allocator>
void tree< T, tree_node_allocator >::copy_ ( const tree< T, tree_node_allocator > &  other)
private
template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::debug_verify_consistency ( ) const

For debugging only: verify internal consistency by inspecting all pointers in the tree (which will also trigger a valgrind error in case something got corrupted).

template<class T , class tree_node_allocator >
int tree< T, tree_node_allocator >::depth ( const iterator_base it)
static

Compute the depth to the root or to a fixed other iterator.

template<class T , class tree_node_allocator >
int tree< T, tree_node_allocator >::depth ( const iterator_base it,
const iterator_base root 
)
static
template<class T , class tree_node_allocator >
bool tree< T, tree_node_allocator >::empty ( ) const

Check if tree is empty.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::pre_order_iterator tree< T, tree_node_allocator >::end ( ) const
inline

Return iterator to the end of the tree.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::end ( const iterator_base pos)
static

Return sibling end iterator for children of given node.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::breadth_first_queued_iterator tree< T, tree_node_allocator >::end_breadth_first ( ) const

Return breadth-first end iterator.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::fixed_depth_iterator tree< T, tree_node_allocator >::end_fixed ( const iterator_base pos,
unsigned int  dp 
) const

Return fixed-depth end iterator.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::leaf_iterator tree< T, tree_node_allocator >::end_leaf ( ) const

Return leaf end iterator for entire tree.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::leaf_iterator tree< T, tree_node_allocator >::end_leaf ( const iterator_base top) const

Return leaf end iterator for the subtree at the given node.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::post_order_iterator tree< T, tree_node_allocator >::end_post ( ) const

Return post-order end iterator of the tree.

template<class T , class tree_node_allocator >
template<typename iter >
bool tree< T, tree_node_allocator >::equal ( const iter &  one,
const iter &  two,
const iter &  three 
) const

Compare two ranges of nodes (compares nodes as well as tree structure).

template<class T , class tree_node_allocator >
template<typename iter , class BinaryPredicate >
bool tree< T, tree_node_allocator >::equal ( const iter &  one,
const iter &  two,
const iter &  three,
BinaryPredicate  fun 
) const
template<class T , class tree_node_allocator >
template<typename iter >
bool tree< T, tree_node_allocator >::equal_subtree ( const iter &  one,
const iter &  two 
) const
template<class T , class tree_node_allocator >
template<typename iter , class BinaryPredicate >
bool tree< T, tree_node_allocator >::equal_subtree ( const iter &  one,
const iter &  two,
BinaryPredicate  fun 
) const
template<class T , class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::erase ( iter  it)

Erase element at position pointed to by iterator, return incremented iterator.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::erase_children ( const iterator_base it)

Erase all children of the node pointed to by iterator.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::erase_left_siblings ( const iterator_base it)

Erase all siblings to the left of the iterator.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::erase_right_siblings ( const iterator_base it)

Erase all siblings to the right of the iterator.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::flatten ( iter  position)

Move all children of node at 'position' to be siblings, returns position.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::head_initialise_ ( )
private
template<class T , class tree_node_allocator >
unsigned int tree< T, tree_node_allocator >::index ( sibling_iterator  it) const

Determine the index of a node in the range of siblings to which it belongs.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert ( iter  position,
const T &  x 
)

Insert node as previous sibling of node pointed to by position.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert ( iter  position,
T &&  x 
)
template<class T, class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::insert ( sibling_iterator  position,
const T &  x 
)

Specialisation of previous member.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert_after ( iter  position,
const T &  x 
)

Insert node as next sibling of node pointed to by position.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert_after ( iter  position,
T &&  x 
)
template<class T , class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert_subtree ( iter  position,
const iterator_base subtree 
)

Insert node (with children) pointed to by subtree as previous sibling of node pointed to by position. Does not change the subtree itself (use move_in or move_in_below for that).

template<class T , class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::insert_subtree_after ( iter  position,
const iterator_base subtree 
)

Insert node (with children) pointed to by subtree as next sibling of node pointed to by position.

template<class T , class tree_node_allocator >
bool tree< T, tree_node_allocator >::is_head ( const iterator_base it)
static

Determine whether the iterator is one of the 'head' nodes at the top level, i.e. has no parent.

template<class T , class tree_node_allocator >
bool tree< T, tree_node_allocator >::is_in_subtree ( const iterator_base position,
const iterator_base begin,
const iterator_base end 
) const

Determine whether node at position is in the subtrees with root in the range.

template<class T , class tree_node_allocator >
bool tree< T, tree_node_allocator >::is_valid ( const iterator_base it) const

Determine whether the iterator is an 'end' iterator and thus not actually pointing to a node.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::iterator tree< T, tree_node_allocator >::lowest_common_ancestor ( const iterator_base one,
const iterator_base two 
) const

Find the lowest common ancestor of two nodes, that is, the deepest node such that both nodes are descendants of it.

template<class T , class tree_node_allocator >
int tree< T, tree_node_allocator >::max_depth ( ) const

Determine the maximal depth of the tree. An empty tree has max_depth=-1.

template<class T , class tree_node_allocator >
int tree< T, tree_node_allocator >::max_depth ( const iterator_base pos) const

Determine the maximal depth of the tree with top node at the given position.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::merge ( sibling_iterator  to1,
sibling_iterator  to2,
sibling_iterator  from1,
sibling_iterator  from2,
bool  duplicate_leaves = false 
)

Merge with other tree, creating new branches and leaves only if they are not already present.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::move_after ( iter  target,
iter  source 
)

Move 'source' node (plus its children) to become the next sibling of 'target'.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::move_before ( iter  target,
iter  source 
)

Move 'source' node (plus its children) to become the previous sibling of 'target'.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::move_before ( sibling_iterator  target,
sibling_iterator  source 
)
template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::move_in ( iter  loc,
tree< T, tree_node_allocator > &  other 
)

Inverse of take_out: inserts the given tree as previous sibling of indicated node by a move operation, that is, the given tree becomes empty. Returns iterator to the top node.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::move_in_as_nth_child ( iter  loc,
size_t  n,
tree< T, tree_node_allocator > &  other 
)

As above, but now make the tree the nth child of the indicated node (if possible).

template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
template<typename iter >
iter tree< T, tree_node_allocator >::move_in_below ( iter  ,
tree< T, tree_node_allocator > &   
)

As above, but now make the tree a child of the indicated node.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::move_ontop ( iter  target,
iter  source 
)

Move 'source' node (plus its children) to become the node at 'target' (erasing the node at 'target').

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator > tree< T, tree_node_allocator >::move_out ( iterator  source)

Extract the subtree starting at the indicated node, removing it from the original tree.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::next_at_same_depth ( iter  position) const

Return iterator to the next node at a given depth.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::next_sibling ( iter  position)
static

Return iterator to the next sibling of a node.

template<class T , class tree_node_allocator >
unsigned int tree< T, tree_node_allocator >::number_of_children ( const iterator_base it)
static

Count the number of children of node at position.

template<class T , class tree_node_allocator >
unsigned int tree< T, tree_node_allocator >::number_of_siblings ( const iterator_base it) const

Count the number of siblings (left and right) of node at iterator. Total nodes at this level is +1.

template<class T, class tree_node_allocator>
tree< T, tree_node_allocator > & tree< T, tree_node_allocator >::operator= ( const tree< T, tree_node_allocator > &  other)
template<class T, class tree_node_allocator>
tree< T, tree_node_allocator > & tree< T, tree_node_allocator >::operator= ( tree< T, tree_node_allocator > &&  x)
template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::parent ( iter  position)
static

Return iterator to the parent of a node.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::prepend_child ( iter  position)
template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::prepend_child ( iter  position,
const T &  x 
)
template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::prepend_child ( iter  position,
T &&  x 
)
template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::prepend_child ( iter  position,
iter  other_position 
)
template<class T , class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::prepend_children ( iter  position,
sibling_iterator  from,
sibling_iterator  to 
)
template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::previous_sibling ( iter  position)
static

Return iterator to the previous sibling of a node.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::reparent ( iter  position,
sibling_iterator  begin,
sibling_iterator  end 
)

Move nodes in range to be children of 'position'.

template<class T , class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::reparent ( iter  position,
iter  from 
)

Move all child nodes of 'from' to be children of 'position'.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::replace ( iter  position,
const T &  x 
)

Replace node at 'position' with other node (keeping same children); 'position' becomes invalid.

template<class T, class tree_node_allocator >
template<class iter >
iter tree< T, tree_node_allocator >::replace ( iter  position,
const iterator_base from 
)

Replace node at 'position' with subtree starting at 'from' (do not erase subtree at 'from'); see above.

template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::replace ( sibling_iterator  orig_begin,
sibling_iterator  orig_end,
sibling_iterator  new_begin,
sibling_iterator  new_end 
)

Replace string of siblings (plus their children) with copy of a new string (with children); see above.

template<class T, class tree_node_allocator >
tree< T, tree_node_allocator >::pre_order_iterator tree< T, tree_node_allocator >::set_head ( const T &  x)

Short-hand to insert topmost node in otherwise empty tree.

template<class T, class tree_node_allocator >
tree< T, tree_node_allocator >::pre_order_iterator tree< T, tree_node_allocator >::set_head ( T &&  x)
template<class T , class tree_node_allocator >
tree< T, tree_node_allocator >::sibling_iterator tree< T, tree_node_allocator >::sibling ( const iterator_base position,
unsigned int  num 
) const

Return iterator to the sibling indicated by index.

template<class T , class tree_node_allocator >
size_t tree< T, tree_node_allocator >::size ( ) const

Count the total number of nodes.

template<class T , class tree_node_allocator >
size_t tree< T, tree_node_allocator >::size ( const iterator_base top) const

Count the total number of nodes below the indicated node (plus one).

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::sort ( sibling_iterator  from,
sibling_iterator  to,
bool  deep = false 
)

Sort (std::sort only moves values of nodes, this one moves children as well).

template<class T , class tree_node_allocator >
template<class StrictWeakOrdering >
void tree< T, tree_node_allocator >::sort ( sibling_iterator  from,
sibling_iterator  to,
StrictWeakOrdering  comp,
bool  deep = false 
)
template<class T , class tree_node_allocator >
tree< T, tree_node_allocator > tree< T, tree_node_allocator >::subtree ( sibling_iterator  from,
sibling_iterator  to 
) const

Extract a new tree formed by the range of siblings plus all their children.

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::subtree ( tree< T, tree_node_allocator > &  tmp,
sibling_iterator  from,
sibling_iterator  to 
) const
template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::swap ( sibling_iterator  it)

Exchange the node (plus subtree) with its sibling node (do nothing if no sibling present).

template<class T , class tree_node_allocator >
void tree< T, tree_node_allocator >::swap ( iterator  one,
iterator  two 
)

Exchange two nodes (plus subtrees). The iterators will remain valid and keep pointing to the same nodes, which now sit at different locations in the tree.

template<class T, class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::wrap ( iter  position,
const T &  x 
)

Replace node with a new node, making the old node (plus subtree) a child of the new node.

template<class T, class tree_node_allocator >
template<typename iter >
iter tree< T, tree_node_allocator >::wrap ( iter  from,
iter  to,
const T &  x 
)

Replace the range of sibling nodes (plus subtrees), making these children of the new node.

Member Data Documentation

template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
tree_node_allocator tree< T, tree_node_allocator >::alloc_
private
template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
tree_node * tree< T, tree_node_allocator >::feet
template<class T, class tree_node_allocator = std::allocator<tree_node_<T> >>
tree_node* tree< T, tree_node_allocator >::head

The documentation for this class was generated from the following file: