tree_msvc7.hpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/* 
 
   $Id: tree_msvc7.hpp 99234 2023-03-01 16:28:17Z ucko $
 
   STL-like templated tree class.
   Copyright (C) 2001  Kasper Peeters <k.peeters@damtp.cam.ac.uk>
 
   See 
  
      http://www.damtp.cam.ac.uk/user/kp229/tree/
 
   for more information and documentation. See the Changelog file for
   other credits.
 
   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
   
   TODO: - 'Move' members are long overdue; will hopefully be incorporated in the
           next release.
         - Fixed depth iterators do not iterate over the entire range if there
           are 'holes' in the tree.
         - If a range uses const iter_base& as end iterator, things will
           inevitably go wrong, because upcast from iter_base to a non-sibling_iter
           is incorrect. This upcast should be removed (and then all illegal uses
           as previously in 'equal' will be flagged by the compiler). This requires
           new copy constructors though.
         - There's a bug in replace(sibling_iterator, ...) when the ranges
           sit next to each other. Turned up in append_child(iter,iter)
           but has been avoided now.
         - "std::operator<" does not work correctly on our iterators, and for some
           reason a globally defined template operator< did not get picked up. 
           Using a comparison class now, but this should be investigated.
*/
 
#ifndef tree_hh_
#define tree_hh_
 
#include <assert.h>
#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>
inline void constructor(T1* p, T2& val) 
   {
   new ((void *) p) T1(val);
   }
 
template <class T1>
inline void constructor(T1* p) 
   {
   new ((void *) p) T1;
   }
 
template <class T1>
inline void destructor(T1* p)
   {
   p->~T1();
   }
 
}
 
template<class T>
class NCBI_CDUTILS_EXPORT 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;
};
 
template <class T, class tree_node_allocator = std::allocator<tree_node_<T> > >
class NCBI_CDUTILS_EXPORT tree {
   protected:
   public:
      typedef tree_node_<T> tree_node;
      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;
            bool           operator==(const iterator_base&) const;
            bool           operator!=(const iterator_base&) const;
 
            void         skip_children(); // do not iterate over children of this node
            unsigned int number_of_children() const;
 
            sibling_iterator begin() const;
            sibling_iterator end() const;
            // ADDED BY VAHAN while conerting CDTRee2 from msvc6 to msvc7
            bool is_valid() const { return node ? true : false ;}
 
            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&);
 
            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&);
 
            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&);
 
            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&);
 
            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_();
      };
 
      // begin/end of tree
      pre_order_iterator   begin() const;
      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;
      // begin/end of children of node
      sibling_iterator     begin(const iterator_base&) const;
      sibling_iterator     end(const iterator_base&) const;
 
      template<typename iter> iter parent(iter) const;
      sibling_iterator previous_sibling(const iterator_base&) const;
      sibling_iterator next_sibling(const iterator_base&) const;
 
      void     clear();
      // erase element at position pointed to by iterator, increment iterator
      template<typename iter> iter erase(iter);
      // erase all children of the node pointed to by iterator
      void     erase_children(const iterator_base&);
 
      // insert node as last child of node pointed to by position (first one inserts empty node)
      template<typename iter> iter append_child(iter position); 
      template<typename iter> iter append_child(iter position, const T& x);
      // the following two append nodes plus their children
      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);
 
      // short-hand to insert topmost node in otherwise empty tree
      pre_order_iterator set_head(const T& x);
      // insert node as previous sibling of node pointed to by position
      template<typename iter> iter insert(iter position, const T& x);
      // specialisation: insert node as previous sibling of node pointed to by position
      //pre_order_iterator insert(sibling_iterator position, const T& x);
      sibling_iterator insert(sibling_iterator position, const T& x);
      // insert node (with children) pointed to by subtree as previous sibling of node pointed to by position
      template<typename iter> iter insert_subtree(iter position, const iterator_base& subtree);
      // insert node as next sibling of node pointed to by position
      template<typename iter> iter insert_after(iter position, const T& x);
 
      // replace node at 'position' with other node (keeping same children); 'position' becomes invalid.
      template<typename iter> iter replace(iter position, const T& x);
      // replace node at 'position' with subtree starting at 'from' (do not erase subtree at 'from'); see above.
      template<typename iter> iter replace(iter position, const iterator_base& from);
      // replace string of siblings (plus their children) with copy of a new string (with children); see above
      sibling_iterator replace(sibling_iterator orig_begin, sibling_iterator orig_end, 
                               sibling_iterator new_begin,  sibling_iterator new_end); 
 
      // move all children of node at 'position' to be siblings, returns position
      template<typename iter> iter flatten(iter position);
      // move nodes in range to be children of 'position'
      template<typename iter> iter reparent(iter position, sibling_iterator begin, sibling_iterator end);
      // ditto, the range being all children of the 'from' node
      template<typename iter> iter reparent(iter position, iter from);
 
      // new style move members, moving nodes plus children to a different 
      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_below(iter target, iter source);
 
      // merge with other tree, creating new branches and leaves only if they are not already present
      void     merge(sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator, 
                     bool duplicate_leaves=false);
      // sort (std::sort only moves values of nodes, this one moves children as well)
      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);
      // compare two ranges of nodes (compares nodes as well as tree structure)
      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;
      // extract a new tree formed by the range of siblings plus all their children
      tree     subtree(sibling_iterator from, sibling_iterator to) const;
      void     subtree(tree&, sibling_iterator from, sibling_iterator to) const;
      // exchange the node (plus subtree) with its sibling node (do nothing if no sibling present)
      void     swap(sibling_iterator it);
      // find a subtree
//    template<class BinaryPredicate>
//    iterator find_subtree(sibling_iterator, sibling_iterator, iterator from, iterator to, BinaryPredicate) const;
      
      // count the total number of nodes
      int      size() const;
      // check if tree is empty
      bool     empty() const;
      // compute the depth to the root
      int      depth(const iterator_base&) const;
      // count the number of children of node at position
      unsigned int number_of_children(const iterator_base&) const;
      // count the number of 'next' siblings of node at iterator
      unsigned int number_of_siblings(const iterator_base&) const;
      // determine whether node at position is in the subtrees with root in the range
      bool     is_in_subtree(const iterator_base& position, const iterator_base& begin, 
                             const iterator_base& end) const;
      // determine whether the iterator is an 'end' iterator and thus not actually
      // pointing to a node
      bool     is_valid(const iterator_base&) const;
 
      // determine the index of a node in the range of siblings to which it belongs.
      unsigned int index(sibling_iterator it) const;
      // inverse of 'index': return the n-th child of the node at position
      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
 
// Return a new tree that is a restructuring of oldTree (*this) after
// re-rooting at the node 'newRoot'.  Any properties of the nodes
// that depend on tree structure (e.g. branch length) are NOT
// adjusted.  User will need to pre-process the nodes to deal
// with such node-specific issues.
 
// Added by CJL:  not part of distributed code
    tree reroot(iterator newRoot) {
 
        tree newTree;
        iterator attachNode, oldParent, z, zz;
        int nChildren;
        int nTopLevelNodes = number_of_siblings(begin());
        
        //  start new tree at selected node
        newTree = subtree(newRoot, next_sibling(newRoot));
        attachNode = newTree.begin();
        oldParent  = parent(newRoot);
        erase(newRoot);
 
        //  climb old tree; attach old parent to its old child in the new tree
        while(oldParent.is_valid()) {
            z = parent(oldParent);
            attachNode = newTree.reparent(attachNode, oldParent, next_sibling(oldParent));
            oldParent = z;
        }
        
        //  Move over any sibling subtrees also attached to head as needed.
        //  Avoid spuriously creating an internal node corresp to 'root' of
        //  an old tree if not needed.
 
        if (nTopLevelNodes > 1) {
            if (nTopLevelNodes > 2) {
                attachNode = newTree.append_child(attachNode, value_type());
            } 
            z = begin();
            while (z.is_valid() && z != end()) {
                zz = next_sibling(z);
                newTree.reparent(attachNode, z, zz);
                z = zz;
                
            }
        }
 
        //  If old root has only one child, remove it and reparent its children
 
        nChildren = newTree.number_of_children(attachNode);
        if (nChildren <= 1) {
            oldParent = newTree.parent(attachNode);
            if (nChildren == 1) {
                z = newTree.reparent(oldParent, attachNode.begin(), next_sibling(attachNode.begin()));
            }
            newTree.erase(attachNode);
        }
        
        return newTree;
    }
// End CJL addition
 
   private:
      tree_node_allocator alloc_;
      void head_initialise_();
      void copy_(const tree<T, tree_node_allocator>& other);
      template<class StrictWeakOrdering>
      class compare_nodes {
         public:
            bool operator()(const tree_node*, const tree_node *);
      };
};
 
//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>
NCBI_CDUTILS_EXPORT 
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 = (tree_node*) alloc_.allocate(1);
   feet = (tree_node*) alloc_.allocate(1);
 
   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>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::previous_sibling(const iterator_base& position) const
   {
   assert(position.node!=0);
   return sibling_iterator(position.node->prev_sibling);
   }
 
template <class T, class tree_node_allocator>
typename tree<T, tree_node_allocator>::sibling_iterator tree<T, tree_node_allocator>::next_sibling(const iterator_base& position) const
   {
   assert(position.node!=0);
   if(position.node->next_sibling==0)
      return end(pre_order_iterator(position.node->parent));
   else
      return sibling_iterator(position.node->next_sibling);
   }
 
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 = (tree_node*) alloc_.allocate(1);
   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 = (tree_node*) alloc_.allocate(1);
   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 = (tree_node*) alloc_.allocate(1);
   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)
      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 = (tree_node*) alloc_.allocate(1);
   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)
      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 = (tree_node*) alloc_.allocate(1);
   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 adding 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 = (tree_node*) alloc_.allocate(1);
   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_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>
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>
template <class StrictWeakOrdering> 
bool tree<T, tree_node_allocator>::compare_nodes<StrictWeakOrdering>::operator()(const tree_node *a, 
                                                                                 const tree_node *b)
   {
   static StrictWeakOrdering comp;
 
   return comp(a->data, b->data);
   }
 
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;
   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=1;
   while(pos->next_sibling && pos->next_sibling!=head) {
      ++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>::iterator_base::operator!=(const iterator_base& 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>::iterator_base::operator==(const iterator_base& 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;
   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!=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: