tree.hh
/*
$Id: tree.hh,v 1.6 2006-07-20 04:41:16 benoitg Exp $
STL-like templated tree class.
Copyright (C) 2001-2005 Kasper Peeters <kasper.peeters@aei.mpg.de>.
*/
/*
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef tree_hh_
#define tree_hh_
#include <cassert>
#include <memory>
#include <stdexcept>
#include <iterator>
#include <set>
// HP-style construct/destroy have gone from the standard,
// so here is a copy.
namespace kp
{
template <class T1, class T2>
void constructor(T1* p, T2& val)
{
new ((void *) p) T1(val);
}
template <class T1>
void constructor(T1* p)
{
new ((void *) p) T1;
}
template <class T1>
void destructor(T1* p)
{
p->~T1();
}
};
template<class T>
class tree_node_ // size: 5*4=20 bytes (on 32 bit arch), can be reduced by 8.
{
public:
tree_node_<T> *parent;
tree_node_<T> *first_child, *last_child;
tree_node_<T> *prev_sibling, *next_sibling;
T data;
}; // __attribute__((packed));
template < class T, class tree_node_allocator = std::allocator<tree_node_<T> > >
class tree
{
protected:
typedef tree_node_<T> tree_node;
public:
typedef T value_type;
class iterator_base;
class pre_order_iterator;
class post_order_iterator;
class sibling_iterator;
tree();
tree(const T&);
tree(const iterator_base&);
tree(const tree<T, tree_node_allocator>&);
~tree();
void operator=(const tree<T, tree_node_allocator>&);
#ifdef __SGI_STL_PORT
class iterator_base : public stlport::bidirectional_iterator<T, ptrdiff_t>
{
#else
class iterator_base
{
#endif
public:
typedef T value_type;
typedef T* pointer;
typedef T& reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef std::bidirectional_iterator_tag iterator_category;
iterator_base();
iterator_base(tree_node *);
T& operator*() const;
T* operator->() const;
void skip_children();
unsigned int number_of_children() const;
sibling_iterator begin() const;
sibling_iterator end() const;
tree_node *node;
protected:
bool skip_current_children_;
};
class pre_order_iterator : public iterator_base
{
public:
pre_order_iterator();
pre_order_iterator(tree_node *);
pre_order_iterator(const iterator_base&);
pre_order_iterator(const sibling_iterator&);
bool operator==(const pre_order_iterator&) const;
bool operator!=(const pre_order_iterator&) const;
pre_order_iterator& operator++();
pre_order_iterator& operator--();
pre_order_iterator operator++(int);
pre_order_iterator operator--(int);
pre_order_iterator& operator+=(unsigned int);
pre_order_iterator& operator-=(unsigned int);
};
class post_order_iterator : public iterator_base
{
public:
post_order_iterator();
post_order_iterator(tree_node *);
post_order_iterator(const iterator_base&);
post_order_iterator(const sibling_iterator&);
bool operator==(const post_order_iterator&) const;
bool operator!=(const post_order_iterator&) const;
post_order_iterator& operator++();
post_order_iterator& operator--();
post_order_iterator operator++(int);
post_order_iterator operator--(int);
post_order_iterator& operator+=(unsigned int);
post_order_iterator& operator-=(unsigned int);
void descend_all();
};
typedef pre_order_iterator iterator;
class fixed_depth_iterator : public iterator_base
{
public:
fixed_depth_iterator();
fixed_depth_iterator(tree_node *);
fixed_depth_iterator(const iterator_base&);
fixed_depth_iterator(const sibling_iterator&);
fixed_depth_iterator(const fixed_depth_iterator&);
bool operator==(const fixed_depth_iterator&) const;
bool operator!=(const fixed_depth_iterator&) const;
fixed_depth_iterator& operator++();
fixed_depth_iterator& operator--();
fixed_depth_iterator operator++(int);
fixed_depth_iterator operator--(int);
fixed_depth_iterator& operator+=(unsigned int);
fixed_depth_iterator& operator-=(unsigned int);
tree_node *first_parent_;
private:
void set_first_parent_();
void find_leftmost_parent_();
};
class sibling_iterator : public iterator_base
{
public:
sibling_iterator();
sibling_iterator(tree_node *);
sibling_iterator(const sibling_iterator&);
sibling_iterator(const iterator_base&);
bool operator==(const sibling_iterator&) const;
bool operator!=(const sibling_iterator&) const;
sibling_iterator& operator++();
sibling_iterator& operator--();
sibling_iterator operator++(int);
sibling_iterator operator--(int);
sibling_iterator& operator+=(unsigned int);
sibling_iterator& operator-=(unsigned int);
tree_node *range_first() const;
tree_node *range_last() const;
tree_node *parent_;
private:
void set_parent_();
};
inline pre_order_iterator begin() const;
inline pre_order_iterator end() const;
post_order_iterator begin_post() const;
post_order_iterator end_post() const;
fixed_depth_iterator begin_fixed(const iterator_base&, unsigned int) const;
fixed_depth_iterator end_fixed(const iterator_base&, unsigned int) const;
sibling_iterator begin(const iterator_base&) const;
sibling_iterator end(const iterator_base&) const;
template<typename iter> iter parent(iter) const;
template<typename iter> iter previous_sibling(iter) const;
template<typename iter> iter next_sibling(iter) const;
template<typename iter> iter next_at_same_depth(iter) const;
void clear();
template<typename iter> iter erase(iter);
void erase_children(const iterator_base&);
template<typename iter> iter append_child(iter position);
template<typename iter> iter append_child(iter position, const T& x);
template<typename iter> iter append_child(iter position, iter other_position);
template<typename iter> iter append_children(iter position, sibling_iterator from, sibling_iterator to);
pre_order_iterator set_head(const T& x);
template<typename iter> iter insert(iter position, const T& x);
sibling_iterator insert(sibling_iterator position, const T& x);
template<typename iter> iter insert_subtree(iter position, const iterator_base& subtree);
template<typename iter> iter insert_after(iter position, const T& x);
template<typename iter> iter replace(iter position, const T& x);
template<typename iter> iter replace(iter position, const iterator_base& from);
sibling_iterator replace(sibling_iterator orig_begin, sibling_iterator orig_end,
sibling_iterator new_begin, sibling_iterator new_end);
template<typename iter> iter flatten(iter position);
template<typename iter> iter reparent(iter position, sibling_iterator begin, sibling_iterator end);
template<typename iter> iter reparent(iter position, iter from);
template<typename iter> iter move_after(iter target, iter source);
template<typename iter> iter move_before(iter target, iter source);
template<typename iter> iter move_ontop(iter target, iter source);
void merge(sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator,
bool duplicate_leaves = false);
void sort(sibling_iterator from, sibling_iterator to, bool deep = false);
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;
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;
void subtree(tree&, sibling_iterator from, sibling_iterator to) const;
void swap(sibling_iterator it);
int size() const;
bool empty() const;
int depth(const iterator_base&) const;
unsigned int number_of_children(const iterator_base&) const;
unsigned int number_of_siblings(const iterator_base&) const;
bool is_in_subtree(const iterator_base& position, const iterator_base& begin,
const iterator_base& end) const;
bool is_valid(const iterator_base&) const;
unsigned int index(sibling_iterator it) const;
sibling_iterator child(const iterator_base& position, unsigned int) const;
class iterator_base_less
{
public:
bool operator()(const typename tree<T, tree_node_allocator>::iterator_base& one,
const typename tree<T, tree_node_allocator>::iterator_base& two) const
{
return one.node < two.node;
}
};
tree_node *head, *feet; // head/feet are always dummy; if an iterator points to them it is invalid
private:
tree_node_allocator alloc_;
void head_initialise_();
void copy_(const tree<T, tree_node_allocator>& other);
template<class StrictWeakOrdering>
class compare_nodes
{
public:
compare_nodes(StrictWeakOrdering comp) : comp_(comp) {};
bool operator()(const tree_node *a, const tree_node *b)
{
static StrictWeakOrdering comp;
return comp(a->data, b->data);
}
private:
StrictWeakOrdering comp_;
};
};
//template <class T, class tree_node_allocator>
//class iterator_base_less {
// public:
// bool operator()(const typename tree<T, tree_node_allocator>::iterator_base& one,
// const typename tree<T, tree_node_allocator>::iterator_base& two) const
// {
// txtout << "operatorclass<" << one.node < two.node << std::endl;
// return one.node < two.node;
// }
//};
//template <class T, class tree_node_allocator>
//bool operator<(const typename tree<T, tree_node_allocator>::iterator& one,
// const typename tree<T, tree_node_allocator>::iterator& two)
// {
// txtout << "operator< " << one.node < two.node << std::endl;
// if(one.node < two.node) return true;
// return false;
// }
template <class T, class tree_node_allocator>
bool operator>(const typename tree<T, tree_node_allocator>::iterator_base& one,
const typename tree<T, tree_node_allocator>::iterator_base& two)
{
if (one.node > two.node) return true;
return false;
}
// Tree
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::tree()
{
head_initialise_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::tree(const T& x)
{
head_initialise_();
set_head(x);
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::tree(const iterator_base& other)
{
head_initialise_();
set_head((*other));
replace(begin(), other);
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::~tree()
{
clear();
alloc_.deallocate(head, 1);
alloc_.deallocate(feet, 1);
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::head_initialise_()
{
head = alloc_.allocate(1, 0); // MSVC does not have default second argument
feet = alloc_.allocate(1, 0);
head->parent = 0;
head->first_child = 0;
head->last_child = 0;
head->prev_sibling = 0; //head;
head->next_sibling = feet; //head;
feet->parent = 0;
feet->first_child = 0;
feet->last_child = 0;
feet->prev_sibling = head;
feet->next_sibling = 0;
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::operator=(const tree<T, tree_node_allocator>& other)
{
copy_(other);
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::tree(const tree<T, tree_node_allocator>& other)
{
head_initialise_();
copy_(other);
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::copy_(const tree<T, tree_node_allocator>& other)
{
clear();
pre_order_iterator it = other.begin(), to = begin();
while (it != other.end())
{
to = insert(to, (*it));
it.skip_children();
++it;
}
to = begin();
it = other.begin();
while (it != other.end())
{
to = replace(to, it);
to.skip_children();
it.skip_children();
++to;
++it;
}
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::clear()
{
if (head)
while (head->next_sibling != feet)
erase(pre_order_iterator(head->next_sibling));
}
template<class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::erase_children(const iterator_base& it)
{
tree_node *cur = it.node->first_child;
tree_node *prev = 0;
while (cur != 0)
{
prev = cur;
cur = cur->next_sibling;
erase_children(pre_order_iterator(prev));
kp::destructor(&prev->data);
alloc_.deallocate(prev, 1);
}
it.node->first_child = 0;
it.node->last_child = 0;
}
template<class T, class tree_node_allocator>
template<class iter>
iter tree<T, tree_node_allocator>::erase(iter it)
{
tree_node *cur = it.node;
assert(cur != head);
iter ret = it;
ret.skip_children();
++ret;
erase_children(it);
if (cur->prev_sibling == 0)
{
cur->parent->first_child = cur->next_sibling;
}
else
{
cur->prev_sibling->next_sibling = cur->next_sibling;
}
if (cur->next_sibling == 0)
{
cur->parent->last_child = cur->prev_sibling;
}
else
{
cur->next_sibling->prev_sibling = cur->prev_sibling;
}
kp::destructor(&cur->data);
alloc_.deallocate(cur, 1);
return ret;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::begin() const
{
return pre_order_iterator(head->next_sibling);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::end() const
{
return pre_order_iterator(feet);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::begin_post() const
{
tree_node *tmp = head->next_sibling;
if (tmp != feet)
{
while (tmp->first_child)
tmp = tmp->first_child;
}
return post_order_iterator(tmp);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::end_post() const
{
return post_order_iterator(feet);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::begin_fixed(const iterator_base& pos, unsigned int dp) const
{
tree_node *tmp = pos.node;
unsigned int curdepth = 0;
while (curdepth < dp) // go down one level
{
while (tmp->first_child == 0)
{
tmp = tmp->next_sibling;
if (tmp == 0)
throw std::range_error("tree: begin_fixed out of range");
}
tmp = tmp->first_child;
++curdepth;
}
return tmp;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::end_fixed(const iterator_base& pos, unsigned int dp) const
{
assert(1 == 0); // FIXME: not correct yet
tree_node *tmp = pos.node;
unsigned int curdepth = 1;
while (curdepth < dp) // go down one level
{
while (tmp->first_child == 0)
{
tmp = tmp->next_sibling;
if (tmp == 0)
throw std::range_error("tree: end_fixed out of range");
}
tmp = tmp->first_child;
++curdepth;
}
return tmp;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::begin(const iterator_base& pos) const
{
if (pos.node->first_child == 0)
{
return end(pos);
}
return pos.node->first_child;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::end(const iterator_base& pos) const
{
sibling_iterator ret(0);
ret.parent_ = pos.node;
return ret;
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::parent(iter position) const
{
assert(position.node != 0);
return iter(position.node->parent);
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::previous_sibling(iter position) const
{
assert(position.node != 0);
iter ret(position);
ret.node = position.node->prev_sibling;
return ret;
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::next_sibling(iter position) const
{
assert(position.node != 0);
iter ret(position);
ret.node = position.node->next_sibling;
return ret;
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::next_at_same_depth(iter position) const
{
assert(position.node != 0);
iter ret(position);
if (position.node->next_sibling)
{
ret.node = position.node->next_sibling;
}
else
{
int relative_depth = 0;
upper:
do
{
ret.node = ret.node->parent;
if (ret.node == 0) return ret;
--relative_depth;
}
while (ret.node->next_sibling == 0);
lower:
ret.node = ret.node->next_sibling;
while (ret.node->first_child == 0)
{
if (ret.node->next_sibling == 0)
goto upper;
ret.node = ret.node->next_sibling;
if (ret.node == 0) return ret;
}
while (relative_depth < 0 && ret.node->first_child != 0)
{
ret.node = ret.node->first_child;
++relative_depth;
}
if (relative_depth < 0)
{
if (ret.node->next_sibling == 0) goto upper;
else goto lower;
}
}
return ret;
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::append_child(iter position)
{
assert(position.node != head);
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data);
tmp->first_child = 0;
tmp->last_child = 0;
tmp->parent = position.node;
if (position.node->last_child != 0)
{
position.node->last_child->next_sibling = tmp;
}
else
{
position.node->first_child = tmp;
}
tmp->prev_sibling = position.node->last_child;
position.node->last_child = tmp;
tmp->next_sibling = 0;
return tmp;
}
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::append_child(iter position, const T& x)
{
// If your program fails here you probably used 'append_child' to add the top
// node to an empty tree. From version 1.45 the top element should be added
// using 'insert'. See the documentation for further information, and sorry about
// the API change.
assert(position.node != head);
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data, x);
tmp->first_child = 0;
tmp->last_child = 0;
tmp->parent = position.node;
if (position.node->last_child != 0)
{
position.node->last_child->next_sibling = tmp;
}
else
{
position.node->first_child = tmp;
}
tmp->prev_sibling = position.node->last_child;
position.node->last_child = tmp;
tmp->next_sibling = 0;
return tmp;
}
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::append_child(iter position, iter other)
{
assert(position.node != head);
sibling_iterator aargh = append_child(position, value_type());
return replace(aargh, other);
}
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)
{
iter ret = from;
while (from != to)
{
insert_subtree(position.end(), from);
++from;
}
return ret;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::set_head(const T& x)
{
assert(head->next_sibling == feet);
return insert(iterator(feet), x);
}
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::insert(iter position, const T& x)
{
if (position.node == 0)
{
position.node = feet; // Backward compatibility: when calling insert on a null node,
// insert before the feet.
}
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data, x);
tmp->first_child = 0;
tmp->last_child = 0;
tmp->parent = position.node->parent;
tmp->next_sibling = position.node;
tmp->prev_sibling = position.node->prev_sibling;
position.node->prev_sibling = tmp;
if (tmp->prev_sibling == 0)
{
if (tmp->parent) // when inserting nodes at the head, there is no parent
tmp->parent->first_child = tmp;
}
else
tmp->prev_sibling->next_sibling = tmp;
return tmp;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::insert(sibling_iterator position, const T& x)
{
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data, x);
tmp->first_child = 0;
tmp->last_child = 0;
tmp->next_sibling = position.node;
if (position.node == 0) // iterator points to end of a subtree
{
tmp->parent = position.parent_;
tmp->prev_sibling = position.range_last();
tmp->parent->last_child = tmp;
}
else
{
tmp->parent = position.node->parent;
tmp->prev_sibling = position.node->prev_sibling;
position.node->prev_sibling = tmp;
}
if (tmp->prev_sibling == 0)
{
if (tmp->parent) // when inserting nodes at the head, there is no parent
tmp->parent->first_child = tmp;
}
else
tmp->prev_sibling->next_sibling = tmp;
return tmp;
}
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::insert_after(iter position, const T& x)
{
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data, x);
tmp->first_child = 0;
tmp->last_child = 0;
tmp->parent = position.node->parent;
tmp->prev_sibling = position.node;
tmp->next_sibling = position.node->next_sibling;
position.node->next_sibling = tmp;
if (tmp->next_sibling == 0)
{
if (tmp->parent) // when inserting nodes at the head, there is no parent
tmp->parent->last_child = tmp;
}
else
{
tmp->next_sibling->prev_sibling = tmp;
}
return tmp;
}
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 dummy
iter it = insert(position, value_type());
// replace dummy with subtree
return replace(it, subtree);
}
// template <class T, class tree_node_allocator>
// template <class iter>
// iter tree<T, tree_node_allocator>::insert_subtree(sibling_iterator position, iter subtree)
// {
// // insert dummy
// iter it(insert(position, value_type()));
// // replace dummy with subtree
// return replace(it, subtree);
// }
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::replace(iter position, const T& x)
{
kp::destructor(&position.node->data);
kp::constructor(&position.node->data, x);
return position;
}
template <class T, class tree_node_allocator>
template <class iter>
iter tree<T, tree_node_allocator>::replace(iter position, const iterator_base& from)
{
assert(position.node != head);
tree_node *current_from = from.node;
tree_node *start_from = from.node;
tree_node *current_to = position.node;
// replace the node at position with head of the replacement tree at from
erase_children(position);
tree_node* tmp = alloc_.allocate(1, 0);
kp::constructor(&tmp->data, (*from));
tmp->first_child = 0;
tmp->last_child = 0;
if (current_to->prev_sibling == 0)
{
current_to->parent->first_child = tmp;
}
else
{
current_to->prev_sibling->next_sibling = tmp;
}
tmp->prev_sibling = current_to->prev_sibling;
if (current_to->next_sibling == 0)
{
current_to->parent->last_child = tmp;
}
else
{
current_to->next_sibling->prev_sibling = tmp;
}
tmp->next_sibling = current_to->next_sibling;
tmp->parent = current_to->parent;
kp::destructor(&current_to->data);
alloc_.deallocate(current_to, 1);
current_to = tmp;
// only at this stage can we fix 'last'
tree_node *last = from.node->next_sibling;
pre_order_iterator toit = tmp;
// copy all children
do
{
assert(current_from != 0);
if (current_from->first_child != 0)
{
current_from = current_from->first_child;
toit = append_child(toit, current_from->data);
}
else
{
while (current_from->next_sibling == 0 && current_from != start_from)
{
current_from = current_from->parent;
toit = parent(toit);
assert(current_from != 0);
}
current_from = current_from->next_sibling;
if (current_from != last)
{
toit = append_child(parent(toit), current_from->data);
}
}
}
while (current_from != last);
return current_to;
}
template <class T, class tree_node_allocator>
typename 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)
{
tree_node *orig_first = orig_begin.node;
tree_node *new_first = new_begin.node;
tree_node *orig_last = orig_first;
while ((++orig_begin) != orig_end)
orig_last = orig_last->next_sibling;
tree_node *new_last = new_first;
while ((++new_begin) != new_end)
new_last = new_last->next_sibling;
// insert all siblings in new_first..new_last before orig_first
bool first = true;
pre_order_iterator ret;
while (1 == 1)
{
pre_order_iterator tt = insert_subtree(pre_order_iterator(orig_first), pre_order_iterator(new_first));
if (first)
{
ret = tt;
first = false;
}
if (new_first == new_last)
break;
new_first = new_first->next_sibling;
}
// erase old range of siblings
bool last = false;
tree_node *next = orig_first;
while (1 == 1)
{
if (next == orig_last)
last = true;
next = next->next_sibling;
erase((pre_order_iterator)orig_first);
if (last)
break;
orig_first = next;
}
return ret;
}
template <class T, class tree_node_allocator>
template <typename iter>
iter tree<T, tree_node_allocator>::flatten(iter position)
{
if (position.node->first_child == 0)
return position;
tree_node *tmp = position.node->first_child;
while (tmp)
{
tmp->parent = position.node->parent;
tmp = tmp->next_sibling;
}
if (position.node->next_sibling)
{
position.node->last_child->next_sibling = position.node->next_sibling;
position.node->next_sibling->prev_sibling = position.node->last_child;
}
else
{
position.node->parent->last_child = position.node->last_child;
}
position.node->next_sibling = position.node->first_child;
position.node->next_sibling->prev_sibling = position.node;
position.node->first_child = 0;
position.node->last_child = 0;
return position;
}
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)
{
tree_node *first = begin.node;
tree_node *last = first;
if (begin == end) return begin;
// determine last node
while ((++begin) != end)
{
last = last->next_sibling;
}
// move subtree
if (first->prev_sibling == 0)
{
first->parent->first_child = last->next_sibling;
}
else
{
first->prev_sibling->next_sibling = last->next_sibling;
}
if (last->next_sibling == 0)
{
last->parent->last_child = first->prev_sibling;
}
else
{
last->next_sibling->prev_sibling = first->prev_sibling;
}
if (position.node->first_child == 0)
{
position.node->first_child = first;
position.node->last_child = last;
first->prev_sibling = 0;
}
else
{
position.node->last_child->next_sibling = first;
first->prev_sibling = position.node->last_child;
position.node->last_child = last;
}
last->next_sibling = 0;
tree_node *pos = first;
while (1 == 1)
{
pos->parent = position.node;
if (pos == last) break;
pos = pos->next_sibling;
}
return first;
}
template <class T, class tree_node_allocator>
template <typename iter> iter tree<T, tree_node_allocator>::reparent(iter position, iter from)
{
if (from.node->first_child == 0) return position;
return reparent(position, from.node->first_child, end(from));
}
template <class T, class tree_node_allocator>
template <typename iter> iter tree<T, tree_node_allocator>::move_after(iter target, iter source)
{
tree_node *dst = target.node;
tree_node *src = source.node;
assert(dst);
assert(src);
if (dst == src) return source;
// take src out of the tree
if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
else src->parent->first_child = src->next_sibling;
if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
else src->parent->last_child = src->prev_sibling;
// connect it to the new point
if (dst->next_sibling != 0) dst->next_sibling->prev_sibling = src;
else dst->parent->last_child = src;
src->next_sibling = dst->next_sibling;
dst->next_sibling = src;
src->prev_sibling = dst;
src->parent = dst->parent;
return src;
}
template <class T, class tree_node_allocator>
template <typename iter> iter tree<T, tree_node_allocator>::move_before(iter target, iter source)
{
tree_node *dst = target.node;
tree_node *src = source.node;
assert(dst);
assert(src);
if (dst == src) return source;
// take src out of the tree
if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
else src->parent->first_child = src->next_sibling;
if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
else src->parent->last_child = src->prev_sibling;
// connect it to the new point
if (dst->prev_sibling != 0) dst->prev_sibling->next_sibling = src;
else dst->parent->first_child = src;
src->prev_sibling = dst->prev_sibling;
dst->prev_sibling = src;
src->next_sibling = dst;
src->parent = dst->parent;
return src;
}
template <class T, class tree_node_allocator>
template <typename iter> iter tree<T, tree_node_allocator>::move_ontop(iter target, iter source)
{
tree_node *dst = target.node;
tree_node *src = source.node;
assert(dst);
assert(src);
if (dst == src) return source;
// remember connection points
tree_node *b_prev_sibling = dst->prev_sibling;
tree_node *b_next_sibling = dst->next_sibling;
tree_node *b_parent = dst->parent;
// remove target
erase(target);
// take src out of the tree
if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
else src->parent->first_child = src->next_sibling;
if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
else src->parent->last_child = src->prev_sibling;
// connect it to the new point
if (b_prev_sibling != 0) b_prev_sibling->next_sibling = src;
else b_parent->first_child = src;
if (b_next_sibling != 0) b_next_sibling->prev_sibling = src;
else b_parent->last_child = src;
src->prev_sibling = b_prev_sibling;
src->next_sibling = b_next_sibling;
src->parent = b_parent;
return src;
}
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)
{
sibling_iterator fnd;
while (from1 != from2)
{
if ((fnd = std::find(to1, to2, (*from1))) != to2) // element found
{
if (from1.begin() == from1.end()) // full depth reached
{
if (duplicate_leaves)
append_child(parent(to1), (*from1));
}
else // descend further
{
merge(fnd.begin(), fnd.end(), from1.begin(), from1.end(), duplicate_leaves);
}
}
else // element missing
{
insert_subtree(to2, from1);
}
++from1;
}
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::sort(sibling_iterator from, sibling_iterator to, bool deep)
{
std::less<T> comp;
sort(from, to, comp, deep);
}
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)
{
if (from == to) return;
// make list of sorted nodes
// CHECK: if multiset stores equivalent nodes in the order in which they
// are inserted, then this routine should be called 'stable_sort'.
std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> > nodes(comp);
sibling_iterator it = from, it2 = to;
while (it != to)
{
nodes.insert(it.node);
++it;
}
// reassemble
--it2;
// prev and next are the nodes before and after the sorted range
tree_node *prev = from.node->prev_sibling;
tree_node *next = it2.node->next_sibling;
typename std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> >::iterator nit = nodes.begin(), eit = nodes.end();
if (prev == 0)
{
if ((*nit)->parent != 0) // to catch "sorting the head" situations, when there is no parent
(*nit)->parent->first_child = (*nit);
}
else prev->next_sibling = (*nit);
--eit;
while (nit != eit)
{
(*nit)->prev_sibling = prev;
if (prev)
prev->next_sibling = (*nit);
prev = (*nit);
++nit;
}
// prev now points to the last-but-one node in the sorted range
if (prev)
prev->next_sibling = (*eit);
// eit points to the last node in the sorted range.
(*eit)->next_sibling = next;
(*eit)->prev_sibling = prev; // missed in the loop above
if (next == 0)
{
if ((*eit)->parent != 0) // to catch "sorting the head" situations, when there is no parent
(*eit)->parent->last_child = (*eit);
}
else next->prev_sibling = (*eit);
if (deep) // sort the children of each node too
{
sibling_iterator bcs(*nodes.begin());
sibling_iterator ecs(*eit);
++ecs;
while (bcs != ecs)
{
sort(begin(bcs), end(bcs), comp, deep);
++bcs;
}
}
}
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
{
std::equal_to<T> comp;
return equal(one_, two, three_, comp);
}
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
{
std::equal_to<T> comp;
return equal_subtree(one_, two_, comp);
}
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
{
pre_order_iterator one(one_), three(three_);
// if(one==two && is_valid(three) && three.number_of_children()!=0)
// return false;
while (one != two && is_valid(three))
{
if (!fun(*one, *three))
return false;
if (one.number_of_children() != three.number_of_children())
return false;
++one;
++three;
}
return true;
}
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
{
pre_order_iterator one(one_), two(two_);
if (!fun(*one, *two)) return false;
if (number_of_children(one) != number_of_children(two)) return false;
return equal(begin(one), end(one), begin(two), fun);
}
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
{
tree tmp;
tmp.set_head(value_type());
tmp.replace(tmp.begin(), tmp.end(), from, to);
return tmp;
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::subtree(tree& tmp, sibling_iterator from, sibling_iterator to) const
{
tmp.set_head(value_type());
tmp.replace(tmp.begin(), tmp.end(), from, to);
}
template <class T, class tree_node_allocator>
int tree<T, tree_node_allocator>::size() const
{
int i = 0;
pre_order_iterator it = begin(), eit = end();
while (it != eit)
{
++i;
++it;
}
return i;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::empty() const
{
pre_order_iterator it = begin(), eit = end();
return (it == eit);
}
template <class T, class tree_node_allocator>
int tree<T, tree_node_allocator>::depth(const iterator_base& it) const
{
tree_node* pos = it.node;
assert(pos != 0);
int ret = 0;
while (pos->parent != 0)
{
pos = pos->parent;
++ret;
}
return ret;
}
template <class T, class tree_node_allocator>
unsigned int tree<T, tree_node_allocator>::number_of_children(const iterator_base& it) const
{
tree_node *pos = it.node->first_child;
if (pos == 0) return 0;
unsigned int ret = 1;
// while(pos!=it.node->last_child) {
// ++ret;
// pos=pos->next_sibling;
// }
while ((pos = pos->next_sibling))
++ret;
return ret;
}
template <class T, class tree_node_allocator>
unsigned int tree<T, tree_node_allocator>::number_of_siblings(const iterator_base& it) const
{
tree_node *pos = it.node;
unsigned int ret = 0;
while (pos->next_sibling &&
pos->next_sibling != head &&
pos->next_sibling != feet)
{
++ret;
pos = pos->next_sibling;
}
return ret;
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::swap(sibling_iterator it)
{
tree_node *nxt = it.node->next_sibling;
if (nxt)
{
if (it.node->prev_sibling)
it.node->prev_sibling->next_sibling = nxt;
else
it.node->parent->first_child = nxt;
nxt->prev_sibling = it.node->prev_sibling;
tree_node *nxtnxt = nxt->next_sibling;
if (nxtnxt)
nxtnxt->prev_sibling = it.node;
else
it.node->parent->last_child = it.node;
nxt->next_sibling = it.node;
it.node->prev_sibling = nxt;
it.node->next_sibling = nxtnxt;
}
}
// template <class BinaryPredicate>
// tree<T, tree_node_allocator>::iterator tree<T, tree_node_allocator>::find_subtree(
// sibling_iterator subfrom, sibling_iterator subto, iterator from, iterator to,
// BinaryPredicate fun) const
// {
// assert(1==0); // this routine is not finished yet.
// while(from!=to) {
// if(fun(*subfrom, *from)) {
//
// }
// }
// return to;
// }
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::is_in_subtree(const iterator_base& it, const iterator_base& begin,
const iterator_base& end) const
{
// FIXME: this should be optimised.
pre_order_iterator tmp = begin;
while (tmp != end)
{
if (tmp == it) return true;
++tmp;
}
return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::is_valid(const iterator_base& it) const
{
if (it.node == 0 || it.node == feet) return false;
else return true;
}
template <class T, class tree_node_allocator>
unsigned int tree<T, tree_node_allocator>::index(sibling_iterator it) const
{
unsigned int ind = 0;
if (it.node->parent == 0)
{
while (it.node->prev_sibling != head)
{
it.node = it.node->prev_sibling;
++ind;
}
}
else
{
while (it.node->prev_sibling != 0)
{
it.node = it.node->prev_sibling;
++ind;
}
}
return ind;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::child(const iterator_base& it, unsigned int num) const
{
tree_node *tmp = it.node->first_child;
while (num--)
{
assert(tmp != 0);
tmp = tmp->next_sibling;
}
return tmp;
}
// Iterator base
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::iterator_base::iterator_base()
: node(0), skip_current_children_(false)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::iterator_base::iterator_base(tree_node *tn)
: node(tn), skip_current_children_(false)
{
}
template <class T, class tree_node_allocator>
T& tree<T, tree_node_allocator>::iterator_base::operator*() const
{
return node->data;
}
template <class T, class tree_node_allocator>
T* tree<T, tree_node_allocator>::iterator_base::operator->() const
{
return &(node->data);
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::post_order_iterator::operator!=(const post_order_iterator& other) const
{
if (other.node != this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::post_order_iterator::operator==(const post_order_iterator& other) const
{
if (other.node == this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::pre_order_iterator::operator!=(const pre_order_iterator& other) const
{
if (other.node != this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::pre_order_iterator::operator==(const pre_order_iterator& other) const
{
if (other.node == this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::sibling_iterator::operator!=(const sibling_iterator& other) const
{
if (other.node != this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
bool tree<T, tree_node_allocator>::sibling_iterator::operator==(const sibling_iterator& other) const
{
if (other.node == this->node) return true;
else return false;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::iterator_base::begin() const
{
sibling_iterator ret(node->first_child);
ret.parent_ = this->node;
return ret;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::iterator_base::end() const
{
sibling_iterator ret(0);
ret.parent_ = node;
return ret;
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::iterator_base::skip_children()
{
skip_current_children_ = true;
}
template <class T, class tree_node_allocator>
unsigned int tree<T, tree_node_allocator>::iterator_base::number_of_children() const
{
tree_node *pos = node->first_child;
if (pos == 0) return 0;
unsigned int ret = 1;
while (pos != node->last_child)
{
++ret;
pos = pos->next_sibling;
}
return ret;
}
// Pre-order iterator
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator()
: iterator_base(0)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(tree_node *tn)
: iterator_base(tn)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(const iterator_base &other)
: iterator_base(other.node)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::pre_order_iterator::pre_order_iterator(const sibling_iterator& other)
: iterator_base(other.node)
{
if (this->node == 0)
{
if (other.range_last() != 0)
this->node = other.range_last();
else
this->node = other.parent_;
this->skip_children();
++(*this);
}
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator++()
{
assert(this->node != 0);
if (!this->skip_current_children_ && this->node->first_child != 0)
{
this->node = this->node->first_child;
}
else
{
this->skip_current_children_ = false;
while (this->node->next_sibling == 0)
{
this->node = this->node->parent;
if (this->node == 0)
return *this;
}
this->node = this->node->next_sibling;
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator--()
{
assert(this->node != 0);
if (this->node->prev_sibling)
{
this->node = this->node->prev_sibling;
while (this->node->last_child)
this->node = this->node->last_child;
}
else
{
this->node = this->node->parent;
if (this->node == 0)
return *this;
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::pre_order_iterator::operator++(int n)
{
pre_order_iterator copy = *this;
++(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator tree<T, tree_node_allocator>::pre_order_iterator::operator--(int n)
{
pre_order_iterator copy = *this;
--(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator+=(unsigned int num)
{
while (num > 0)
{
++(*this);
--num;
}
return (*this);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::pre_order_iterator& tree<T, tree_node_allocator>::pre_order_iterator::operator-=(unsigned int num)
{
while (num > 0)
{
--(*this);
--num;
}
return (*this);
}
// Post-order iterator
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator()
: iterator_base(0)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(tree_node *tn)
: iterator_base(tn)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(const iterator_base &other)
: iterator_base(other.node)
{
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::post_order_iterator::post_order_iterator(const sibling_iterator& other)
: iterator_base(other.node)
{
if (this->node == 0)
{
if (other.range_last() != 0)
this->node = other.range_last();
else
this->node = other.parent_;
this->skip_children();
++(*this);
}
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator++()
{
assert(this->node != 0);
if (this->node->next_sibling == 0)
{
this->node = this->node->parent;
this->skip_current_children_ = false;
}
else
{
this->node = this->node->next_sibling;
if (this->skip_current_children_)
{
this->skip_current_children_ = false;
}
else
{
while (this->node->first_child)
this->node = this->node->first_child;
}
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator--()
{
assert(this->node != 0);
if (this->skip_current_children_ || this->node->last_child == 0)
{
this->skip_current_children_ = false;
while (this->node->prev_sibling == 0)
this->node = this->node->parent;
this->node = this->node->prev_sibling;
}
else
{
this->node = this->node->last_child;
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::post_order_iterator::operator++(int)
{
post_order_iterator copy = *this;
++(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator tree<T, tree_node_allocator>::post_order_iterator::operator--(int)
{
post_order_iterator copy = *this;
--(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator+=(unsigned int num)
{
while (num > 0)
{
++(*this);
--num;
}
return (*this);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::post_order_iterator& tree<T, tree_node_allocator>::post_order_iterator::operator-=(unsigned int num)
{
while (num > 0)
{
--(*this);
--num;
}
return (*this);
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::post_order_iterator::descend_all()
{
assert(this->node != 0);
while (this->node->first_child)
this->node = this->node->first_child;
}
// Fixed depth iterator
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator()
: iterator_base()
{
set_first_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(tree_node *tn)
: iterator_base(tn)
{
set_first_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const iterator_base& other)
: iterator_base(other.node)
{
set_first_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const sibling_iterator& other)
: iterator_base(other.node), first_parent_(other.parent_)
{
find_leftmost_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::fixed_depth_iterator::fixed_depth_iterator(const fixed_depth_iterator& other)
: iterator_base(other.node), first_parent_(other.first_parent_)
{
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::fixed_depth_iterator::set_first_parent_()
{
return; // FIXME: we do not use first_parent_ yet, and it actually needs some serious reworking if
// it is ever to work at the 'head' level.
first_parent_ = 0;
if (this->node == 0) return;
if (this->node->parent != 0)
first_parent_ = this->node->parent;
if (first_parent_)
find_leftmost_parent_();
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::fixed_depth_iterator::find_leftmost_parent_()
{
return; // FIXME: see 'set_first_parent()'
tree_node *tmppar = first_parent_;
while (tmppar->prev_sibling)
{
tmppar = tmppar->prev_sibling;
if (tmppar->first_child)
first_parent_ = tmppar;
}
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator++()
{
assert(this->node != 0);
if (this->node->next_sibling)
{
this->node = this->node->next_sibling;
}
else
{
int relative_depth = 0;
upper:
do
{
this->node = this->node->parent;
if (this->node == 0) return *this;
--relative_depth;
}
while (this->node->next_sibling == 0);
lower:
this->node = this->node->next_sibling;
while (this->node->first_child == 0)
{
if (this->node->next_sibling == 0)
goto upper;
this->node = this->node->next_sibling;
if (this->node == 0) return *this;
}
while (relative_depth < 0 && this->node->first_child != 0)
{
this->node = this->node->first_child;
++relative_depth;
}
if (relative_depth < 0)
{
if (this->node->next_sibling == 0) goto upper;
else goto lower;
}
}
return *this;
// if(this->node->next_sibling!=0) {
// this->node=this->node->next_sibling;
// assert(this->node!=0);
// if(this->node->parent==0 && this->node->next_sibling==0) // feet element
// this->node=0;
// }
// else {
// tree_node *par=this->node->parent;
// do {
// par=par->next_sibling;
// if(par==0) { // FIXME: need to keep track of this!
// this->node=0;
// return *this;
// }
// } while(par->first_child==0);
// this->node=par->first_child;
// }
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator--()
{
assert(this->node != 0);
if (this->node->prev_sibling != 0)
{
this->node = this->node->prev_sibling;
assert(this->node != 0);
if (this->node->parent == 0 && this->node->prev_sibling == 0) // head element
this->node = 0;
}
else
{
tree_node *par = this->node->parent;
do
{
par = par->prev_sibling;
if (par == 0) // FIXME: need to keep track of this!
{
this->node = 0;
return *this;
}
}
while (par->last_child == 0);
this->node = par->last_child;
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::fixed_depth_iterator::operator++(int)
{
fixed_depth_iterator copy = *this;
++(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator tree<T, tree_node_allocator>::fixed_depth_iterator::operator--(int)
{
fixed_depth_iterator copy = *this;
--(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator-=(unsigned int num)
{
while (num > 0)
{
--(*this);
--(num);
}
return (*this);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::fixed_depth_iterator& tree<T, tree_node_allocator>::fixed_depth_iterator::operator+=(unsigned int num)
{
while (num > 0)
{
++(*this);
--(num);
}
return *this;
}
// FIXME: add the other members of fixed_depth_iterator.
// Sibling iterator
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator()
: iterator_base()
{
set_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(tree_node *tn)
: iterator_base(tn)
{
set_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(const iterator_base& other)
: iterator_base(other.node)
{
set_parent_();
}
template <class T, class tree_node_allocator>
tree<T, tree_node_allocator>::sibling_iterator::sibling_iterator(const sibling_iterator& other)
: iterator_base(other), parent_(other.parent_)
{
}
template <class T, class tree_node_allocator>
void tree<T, tree_node_allocator>::sibling_iterator::set_parent_()
{
parent_ = 0;
if (this->node == 0) return;
if (this->node->parent != 0)
parent_ = this->node->parent;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator++()
{
if (this->node)
this->node = this->node->next_sibling;
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator--()
{
if (this->node) this->node = this->node->prev_sibling;
else
{
assert(parent_);
this->node = parent_->last_child;
}
return *this;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::sibling_iterator::operator++(int)
{
sibling_iterator copy = *this;
++(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::sibling_iterator::operator--(int)
{
sibling_iterator copy = *this;
--(*this);
return copy;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator+=(unsigned int num)
{
while (num > 0)
{
++(*this);
--num;
}
return (*this);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator& tree<T, tree_node_allocator>::sibling_iterator::operator-=(unsigned int num)
{
while (num > 0)
{
--(*this);
--num;
}
return (*this);
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::tree_node *tree<T, tree_node_allocator>::sibling_iterator::range_first() const
{
tree_node *tmp = parent_->first_child;
return tmp;
}
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::tree_node *tree<T, tree_node_allocator>::sibling_iterator::range_last() const
{
return parent_->last_child;
}
#endif
// Local variables:
// default-tab-width: 3
// End:
tree::clear
void clear()
Erase all nodes of the tree.
Definition: tree.hh:522
tree::replace
iter replace(iter position, const T &x)
Replace node at 'position' with other node (keeping same children); 'position' becomes invalid...
Definition: tree.hh:935
tree::swap
void swap(sibling_iterator it)
Exchange the node (plus subtree) with its sibling node (do nothing if no sibling present).
Definition: tree.hh:1472
tree::number_of_children
unsigned int number_of_children(const iterator_base &) const
Count the number of children of node at position.
Definition: tree.hh:1441
tree::end_fixed
fixed_depth_iterator end_fixed(const iterator_base &, unsigned int) const
Return fixed-depth iterator to end of the nodes at given depth.
Definition: tree.hh:629
tree::erase_children
void erase_children(const iterator_base &)
Erase all children of the node pointed to by iterator.
Definition: tree.hh:530
tree::reparent
iter reparent(iter position, sibling_iterator begin, sibling_iterator end)
Move nodes in range to be children of 'position'.
Definition: tree.hh:1094
tree::begin_post
post_order_iterator begin_post() const
Return post-order iterator to the beginning of the tree.
Definition: tree.hh:592
tree::erase
iter erase(iter)
Erase element at position pointed to by iterator, return incremented iterator.
Definition: tree.hh:549
position
SGMLApplication::Position position
Definition: messages.cpp:28
tree::iterator_base::number_of_children
unsigned int number_of_children() const
Number of children of the node pointed to by the iterator.
tree::set_head
pre_order_iterator set_head(const T &x)
Short-hand to insert topmost node in otherwise empty tree.
Definition: tree.hh:820
tree::iterator_base::skip_children
void skip_children()
When called, the next increment/decrement skips children of this node.
tree::flatten
iter flatten(iter position)
Move all children of node at 'position' to be siblings, returns position.
Definition: tree.hh:1063
tree::subtree
tree subtree(sibling_iterator from, sibling_iterator to) const
Extract a new tree formed by the range of siblings plus all their children.
Definition: tree.hh:1391
tree::depth
int depth(const iterator_base &) const
Compute the depth to the root.
Definition: tree.hh:1427
tree::move_before
iter move_before(iter target, iter source)
Move 'source' node (plus its children) to become the previous sibling of 'target'.
Definition: tree.hh:1181
tree::empty
bool empty() const
Check if tree is empty.
Definition: tree.hh:1420
tree::sibling_iterator
Iterator which traverses only the nodes which are siblings of each other.
Definition: tree.hh:230
tree::end
pre_order_iterator end() const
Return iterator to the end of the tree.
Definition: tree.hh:586
tree::size
int size() const
Count the total number of nodes.
Definition: tree.hh:1407
tree::insert_after
iter insert_after(iter position, const T &x)
Insert node as next sibling of node pointed to by position.
Definition: tree.hh:889
tree_node_
A node in the tree, combining links to other nodes as well as the actual data.
Definition: tree.hh:95
tree::end_post
post_order_iterator end_post() const
Return post-order iterator to the end of the tree.
Definition: tree.hh:604
tree::iterator_base
Base class for iterators, only pointers stored, no traversal logic.
Definition: tree.hh:130
tree::begin
pre_order_iterator begin() const
Return iterator to the beginning of the tree.
Definition: tree.hh:580
tree::previous_sibling
iter previous_sibling(iter) const
Return iterator to the previous sibling of a node.
Definition: tree.hh:676
tree::insert_subtree
iter 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...
Definition: tree.hh:915
tree::parent
iter parent(iter) const
Return iterator to the parent of a node.
Definition: tree.hh:668
tree::next_sibling
iter next_sibling(iter) const
Return iterator to the next sibling of a node.
Definition: tree.hh:686
tree::equal
bool equal(const iter &one, const iter &two, const iter &three) const
Compare two ranges of nodes (compares nodes as well as tree structure).
Definition: tree.hh:1345
tree::is_in_subtree
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.
Definition: tree.hh:1508
tree::post_order_iterator::descend_all
void descend_all()
Set iterator to the first child as deep as possible down the tree.
tree::is_valid
bool is_valid(const iterator_base &) const
Determine whether the iterator is an 'end' iterator and thus not actually pointing to a node...
Definition: tree.hh:1522
tree::merge
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...
Definition: tree.hh:1242
tree::post_order_iterator
Depth-first iterator, first accessing the children, then the node itself.
Definition: tree.hh:180
tree::value_type
T value_type
Value of the data stored at a node.
Definition: tree.hh:111
tree::number_of_siblings
unsigned int number_of_siblings(const iterator_base &) const
Count the number of 'next' siblings of node at iterator.
Definition: tree.hh:1457
tree::append_child
iter append_child(iter position)
Insert empty node as last child of node pointed to by position.
Definition: tree.hh:741
tree::insert
iter insert(iter position, const T &x)
Insert node as previous sibling of node pointed to by position.
Definition: tree.hh:828
tree::index
unsigned int index(sibling_iterator it) const
Determine the index of a node in the range of siblings to which it belongs.
Definition: tree.hh:1529
tree::sort
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).
Definition: tree.hh:1271
tree
Definition: tree.hh:105
tree::fixed_depth_iterator
Iterator which traverses only the nodes at a given depth from the root.
Definition: tree.hh:205
tree::begin_fixed
fixed_depth_iterator begin_fixed(const iterator_base &, unsigned int) const
Return fixed-depth iterator to the first node at a given depth.
Definition: tree.hh:610
tree::move_ontop
iter move_ontop(iter target, iter source)
Move 'source' node (plus its children) to become the node at 'target' (erasing the node at 'target')...
Definition: tree.hh:1207
tree::pre_order_iterator
Depth-first iterator, first accessing the node, then its children.
Definition: tree.hh:161
tree::child
sibling_iterator child(const iterator_base &position, unsigned int) const
Inverse of 'index': return the n-th child of the node at position.
Definition: tree.hh:1553
tree::iterator_base_less
Comparator class for iterators (compares the actual node content, not pointer values).
Definition: tree.hh:373
tree::append_children
iter append_children(iter position, sibling_iterator from, sibling_iterator to)
Append the nodes in the from-to range (plus their children) as children of position.
Definition: tree.hh:807
tree::move_after
iter move_after(iter target, iter source)
Move 'source' node (plus its children) to become the next sibling of 'target'.
Definition: tree.hh:1154
tree::iterator
pre_order_iterator iterator
The default iterator type throughout the tree class.
Definition: tree.hh:202
tree::next_at_same_depth
iter next_at_same_depth(iter) const
Return iterator to the next node at a given depth.
Definition: tree.hh:696