73 template <
class T1,
class T2>
74 void constructor(T1* p, T2& val)
76 new ((
void *) p) T1(val);
80 void constructor(T1* p)
86 void destructor(T1* p)
104 template <
class T,
class tree_node_allocator = std::allocator<tree_node_<T> > >
114 class pre_order_iterator;
115 class post_order_iterator;
116 class sibling_iterator;
120 tree(
const iterator_base&);
126 #ifdef __SGI_STL_PORT
127 class iterator_base :
public stlport::bidirectional_iterator<T, ptrdiff_t>
134 typedef T value_type;
136 typedef T& reference;
137 typedef size_t size_type;
138 typedef ptrdiff_t difference_type;
139 typedef std::bidirectional_iterator_tag iterator_category;
144 T& operator*()
const;
145 T* operator->()
const;
157 bool skip_current_children_;
225 void set_first_parent_();
226 void find_leftmost_parent_();
272 template<
typename iter> iter
parent(iter)
const;
283 template<
typename iter> iter
erase(iter);
323 template<
typename iter> iter
move_after(iter target, iter source);
325 template<
typename iter> iter
move_before(iter target, iter source);
327 template<
typename iter> iter
move_ontop(iter target, iter source);
331 bool duplicate_leaves =
false);
334 template<
class StrictWeakOrdering>
337 template<
typename iter>
338 bool equal(
const iter& one,
const iter& two,
const iter& three)
const;
339 template<
typename iter,
class BinaryPredicate>
340 bool equal(
const iter& one,
const iter& two,
const iter& three, BinaryPredicate)
const;
341 template<
typename iter>
342 bool equal_subtree(
const iter& one,
const iter& two)
const;
343 template<
typename iter,
class BinaryPredicate>
344 bool equal_subtree(
const iter& one,
const iter& two, BinaryPredicate)
const;
379 return one.node < two.node;
384 tree_node_allocator alloc_;
385 void head_initialise_();
389 template<
class StrictWeakOrdering>
393 compare_nodes(StrictWeakOrdering comp) : comp_(comp) {};
395 bool operator()(
const tree_node *a,
const tree_node *b)
397 static StrictWeakOrdering comp;
398 return comp(a->data, b->data);
401 StrictWeakOrdering comp_;
425 template <
class T,
class tree_node_allocator>
429 if (one.node > two.node)
return true;
437 template <
class T,
class tree_node_allocator>
443 template <
class T,
class tree_node_allocator>
450 template <
class T,
class tree_node_allocator>
458 template <
class T,
class tree_node_allocator>
462 alloc_.deallocate(head, 1);
463 alloc_.deallocate(feet, 1);
466 template <
class T,
class tree_node_allocator>
469 head = alloc_.allocate(1, 0);
470 feet = alloc_.allocate(1, 0);
473 head->first_child = 0;
474 head->last_child = 0;
475 head->prev_sibling = 0;
476 head->next_sibling = feet;
479 feet->first_child = 0;
480 feet->last_child = 0;
481 feet->prev_sibling = head;
482 feet->next_sibling = 0;
485 template <
class T,
class tree_node_allocator>
491 template <
class T,
class tree_node_allocator>
498 template <
class T,
class tree_node_allocator>
502 pre_order_iterator it = other.
begin(), to =
begin();
503 while (it != other.
end())
511 while (it != other.
end())
521 template <
class T,
class tree_node_allocator>
525 while (head->next_sibling != feet)
529 template<
class T,
class tree_node_allocator>
538 cur = cur->next_sibling;
540 kp::destructor(&prev->data);
541 alloc_.deallocate(prev, 1);
543 it.node->first_child = 0;
544 it.node->last_child = 0;
547 template<
class T,
class tree_node_allocator>
557 if (cur->prev_sibling == 0)
559 cur->parent->first_child = cur->next_sibling;
563 cur->prev_sibling->next_sibling = cur->next_sibling;
565 if (cur->next_sibling == 0)
567 cur->parent->last_child = cur->prev_sibling;
571 cur->next_sibling->prev_sibling = cur->prev_sibling;
574 kp::destructor(&cur->data);
575 alloc_.deallocate(cur, 1);
579 template <
class T,
class tree_node_allocator>
585 template <
class T,
class tree_node_allocator>
591 template <
class T,
class tree_node_allocator>
597 while (tmp->first_child)
598 tmp = tmp->first_child;
603 template <
class T,
class tree_node_allocator>
609 template <
class T,
class tree_node_allocator>
613 unsigned int curdepth = 0;
614 while (curdepth < dp)
616 while (tmp->first_child == 0)
618 tmp = tmp->next_sibling;
620 throw std::range_error(
"tree: begin_fixed out of range");
622 tmp = tmp->first_child;
628 template <
class T,
class tree_node_allocator>
633 unsigned int curdepth = 1;
634 while (curdepth < dp)
636 while (tmp->first_child == 0)
638 tmp = tmp->next_sibling;
640 throw std::range_error(
"tree: end_fixed out of range");
642 tmp = tmp->first_child;
648 template <
class T,
class tree_node_allocator>
651 if (pos.node->first_child == 0)
655 return pos.node->first_child;
658 template <
class T,
class tree_node_allocator>
662 ret.parent_ = pos.node;
666 template <
class T,
class tree_node_allocator>
667 template <
typename iter>
670 assert(position.node != 0);
671 return iter(position.node->parent);
674 template <
class T,
class tree_node_allocator>
675 template <
typename iter>
678 assert(position.node != 0);
680 ret.node = position.node->prev_sibling;
684 template <
class T,
class tree_node_allocator>
685 template <
typename iter>
688 assert(position.node != 0);
690 ret.node = position.node->next_sibling;
694 template <
class T,
class tree_node_allocator>
695 template <
typename iter>
698 assert(position.node != 0);
701 if (position.node->next_sibling)
703 ret.node = position.node->next_sibling;
707 int relative_depth = 0;
711 ret.node = ret.node->parent;
712 if (ret.node == 0)
return ret;
715 while (ret.node->next_sibling == 0);
717 ret.node = ret.node->next_sibling;
718 while (ret.node->first_child == 0)
720 if (ret.node->next_sibling == 0)
722 ret.node = ret.node->next_sibling;
723 if (ret.node == 0)
return ret;
725 while (relative_depth < 0 && ret.node->first_child != 0)
727 ret.node = ret.node->first_child;
730 if (relative_depth < 0)
732 if (ret.node->next_sibling == 0)
goto upper;
739 template <
class T,
class tree_node_allocator>
740 template <
typename iter>
743 assert(position.node != head);
746 kp::constructor(&tmp->data);
747 tmp->first_child = 0;
750 tmp->parent = position.node;
751 if (position.node->last_child != 0)
753 position.node->last_child->next_sibling = tmp;
757 position.node->first_child = tmp;
759 tmp->prev_sibling = position.node->last_child;
760 position.node->last_child = tmp;
761 tmp->next_sibling = 0;
765 template <
class T,
class tree_node_allocator>
766 template <
class iter>
773 assert(position.node != head);
776 kp::constructor(&tmp->data, x);
777 tmp->first_child = 0;
780 tmp->parent = position.node;
781 if (position.node->last_child != 0)
783 position.node->last_child->next_sibling = tmp;
787 position.node->first_child = tmp;
789 tmp->prev_sibling = position.node->last_child;
790 position.node->last_child = tmp;
791 tmp->next_sibling = 0;
795 template <
class T,
class tree_node_allocator>
796 template <
class iter>
799 assert(position.node != head);
805 template <
class T,
class tree_node_allocator>
806 template <
class iter>
819 template <
class T,
class tree_node_allocator>
822 assert(head->next_sibling == feet);
826 template <
class T,
class tree_node_allocator>
827 template <
class iter>
830 if (position.node == 0)
832 position.node = feet;
836 kp::constructor(&tmp->data, x);
837 tmp->first_child = 0;
840 tmp->parent = position.node->parent;
841 tmp->next_sibling = position.node;
842 tmp->prev_sibling = position.node->prev_sibling;
843 position.node->prev_sibling = tmp;
845 if (tmp->prev_sibling == 0)
848 tmp->parent->first_child = tmp;
851 tmp->prev_sibling->next_sibling = tmp;
855 template <
class T,
class tree_node_allocator>
859 kp::constructor(&tmp->data, x);
860 tmp->first_child = 0;
863 tmp->next_sibling = position.node;
864 if (position.node == 0)
866 tmp->parent = position.parent_;
867 tmp->prev_sibling = position.range_last();
868 tmp->parent->last_child = tmp;
872 tmp->parent = position.node->parent;
873 tmp->prev_sibling = position.node->prev_sibling;
874 position.node->prev_sibling = tmp;
877 if (tmp->prev_sibling == 0)
880 tmp->parent->first_child = tmp;
883 tmp->prev_sibling->next_sibling = tmp;
887 template <
class T,
class tree_node_allocator>
888 template <
class iter>
892 kp::constructor(&tmp->data, x);
893 tmp->first_child = 0;
896 tmp->parent = position.node->parent;
897 tmp->prev_sibling = position.node;
898 tmp->next_sibling = position.node->next_sibling;
899 position.node->next_sibling = tmp;
901 if (tmp->next_sibling == 0)
904 tmp->parent->last_child = tmp;
908 tmp->next_sibling->prev_sibling = tmp;
913 template <
class T,
class tree_node_allocator>
914 template <
class iter>
933 template <
class T,
class tree_node_allocator>
934 template <
class iter>
937 kp::destructor(&position.node->data);
938 kp::constructor(&position.node->data, x);
942 template <
class T,
class tree_node_allocator>
943 template <
class iter>
946 assert(position.node != head);
954 kp::constructor(&tmp->data, (*from));
955 tmp->first_child = 0;
957 if (current_to->prev_sibling == 0)
959 current_to->parent->first_child = tmp;
963 current_to->prev_sibling->next_sibling = tmp;
965 tmp->prev_sibling = current_to->prev_sibling;
966 if (current_to->next_sibling == 0)
968 current_to->parent->last_child = tmp;
972 current_to->next_sibling->prev_sibling = tmp;
974 tmp->next_sibling = current_to->next_sibling;
975 tmp->parent = current_to->parent;
976 kp::destructor(¤t_to->data);
977 alloc_.deallocate(current_to, 1);
981 tree_node *last = from.node->next_sibling;
987 assert(current_from != 0);
988 if (current_from->first_child != 0)
990 current_from = current_from->first_child;
995 while (current_from->next_sibling == 0 && current_from != start_from)
997 current_from = current_from->parent;
999 assert(current_from != 0);
1001 current_from = current_from->next_sibling;
1002 if (current_from != last)
1008 while (current_from != last);
1013 template <
class T,
class tree_node_allocator>
1020 tree_node *orig_first = orig_begin.node;
1023 while ((++orig_begin) != orig_end)
1024 orig_last = orig_last->next_sibling;
1026 while ((++new_begin) != new_end)
1027 new_last = new_last->next_sibling;
1040 if (new_first == new_last)
1042 new_first = new_first->next_sibling;
1050 if (next == orig_last)
1052 next = next->next_sibling;
1061 template <
class T,
class tree_node_allocator>
1062 template <
typename iter>
1065 if (position.node->first_child == 0)
1068 tree_node *tmp = position.node->first_child;
1071 tmp->parent = position.node->parent;
1072 tmp = tmp->next_sibling;
1074 if (position.node->next_sibling)
1076 position.node->last_child->next_sibling = position.node->next_sibling;
1077 position.node->next_sibling->prev_sibling = position.node->last_child;
1081 position.node->parent->last_child = position.node->last_child;
1083 position.node->next_sibling = position.node->first_child;
1084 position.node->next_sibling->prev_sibling = position.node;
1085 position.node->first_child = 0;
1086 position.node->last_child = 0;
1092 template <
class T,
class tree_node_allocator>
1093 template <
typename iter>
1098 if (begin == end)
return begin;
1100 while ((++begin) != end)
1102 last = last->next_sibling;
1105 if (first->prev_sibling == 0)
1107 first->parent->first_child = last->next_sibling;
1111 first->prev_sibling->next_sibling = last->next_sibling;
1113 if (last->next_sibling == 0)
1115 last->parent->last_child = first->prev_sibling;
1119 last->next_sibling->prev_sibling = first->prev_sibling;
1121 if (position.node->first_child == 0)
1123 position.node->first_child = first;
1124 position.node->last_child = last;
1125 first->prev_sibling = 0;
1129 position.node->last_child->next_sibling = first;
1130 first->prev_sibling = position.node->last_child;
1131 position.node->last_child = last;
1133 last->next_sibling = 0;
1138 pos->parent = position.node;
1139 if (pos == last)
break;
1140 pos = pos->next_sibling;
1146 template <
class T,
class tree_node_allocator>
1149 if (from.node->first_child == 0)
return position;
1150 return reparent(position, from.node->first_child,
end(from));
1153 template <
class T,
class tree_node_allocator>
1161 if (dst == src)
return source;
1164 if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
1165 else src->parent->first_child = src->next_sibling;
1166 if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
1167 else src->parent->last_child = src->prev_sibling;
1170 if (dst->next_sibling != 0) dst->next_sibling->prev_sibling = src;
1171 else dst->parent->last_child = src;
1172 src->next_sibling = dst->next_sibling;
1173 dst->next_sibling = src;
1174 src->prev_sibling = dst;
1175 src->parent = dst->parent;
1180 template <
class T,
class tree_node_allocator>
1188 if (dst == src)
return source;
1191 if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
1192 else src->parent->first_child = src->next_sibling;
1193 if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
1194 else src->parent->last_child = src->prev_sibling;
1197 if (dst->prev_sibling != 0) dst->prev_sibling->next_sibling = src;
1198 else dst->parent->first_child = src;
1199 src->prev_sibling = dst->prev_sibling;
1200 dst->prev_sibling = src;
1201 src->next_sibling = dst;
1202 src->parent = dst->parent;
1206 template <
class T,
class tree_node_allocator>
1214 if (dst == src)
return source;
1217 tree_node *b_prev_sibling = dst->prev_sibling;
1218 tree_node *b_next_sibling = dst->next_sibling;
1225 if (src->prev_sibling != 0) src->prev_sibling->next_sibling = src->next_sibling;
1226 else src->parent->first_child = src->next_sibling;
1227 if (src->next_sibling != 0) src->next_sibling->prev_sibling = src->prev_sibling;
1228 else src->parent->last_child = src->prev_sibling;
1231 if (b_prev_sibling != 0) b_prev_sibling->next_sibling = src;
1232 else b_parent->first_child = src;
1233 if (b_next_sibling != 0) b_next_sibling->prev_sibling = src;
1234 else b_parent->last_child = src;
1235 src->prev_sibling = b_prev_sibling;
1236 src->next_sibling = b_next_sibling;
1237 src->parent = b_parent;
1241 template <
class T,
class tree_node_allocator>
1244 bool duplicate_leaves)
1247 while (from1 != from2)
1249 if ((fnd = std::find(to1, to2, (*from1))) != to2)
1251 if (from1.begin() == from1.end())
1253 if (duplicate_leaves)
1258 merge(fnd.begin(), fnd.end(), from1.begin(), from1.end(), duplicate_leaves);
1270 template <
class T,
class tree_node_allocator>
1274 sort(from, to, comp, deep);
1277 template <
class T,
class tree_node_allocator>
1278 template <
class StrictWeakOrdering>
1280 StrictWeakOrdering comp,
bool deep)
1282 if (from == to)
return;
1286 std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> > nodes(comp);
1287 sibling_iterator it = from, it2 = to;
1290 nodes.insert(it.node);
1297 tree_node *prev = from.node->prev_sibling;
1298 tree_node *next = it2.node->next_sibling;
1299 typename std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> >
::iterator nit = nodes.begin(), eit = nodes.end();
1302 if ((*nit)->parent != 0)
1303 (*nit)->parent->first_child = (*nit);
1305 else prev->next_sibling = (*nit);
1310 (*nit)->prev_sibling = prev;
1312 prev->next_sibling = (*nit);
1318 prev->next_sibling = (*eit);
1321 (*eit)->next_sibling = next;
1322 (*eit)->prev_sibling = prev;
1325 if ((*eit)->parent != 0)
1326 (*eit)->parent->last_child = (*eit);
1328 else next->prev_sibling = (*eit);
1332 sibling_iterator bcs(*nodes.begin());
1333 sibling_iterator ecs(*eit);
1343 template <
class T,
class tree_node_allocator>
1344 template <
typename iter>
1347 std::equal_to<T> comp;
1348 return equal(one_, two, three_, comp);
1351 template <
class T,
class tree_node_allocator>
1352 template <
typename iter>
1355 std::equal_to<T> comp;
1356 return equal_subtree(one_, two_, comp);
1359 template <
class T,
class tree_node_allocator>
1360 template <
typename iter,
class BinaryPredicate>
1363 pre_order_iterator one(one_), three(three_);
1367 while (one != two &&
is_valid(three))
1369 if (!fun(*one, *three))
1379 template <
class T,
class tree_node_allocator>
1380 template <
typename iter,
class BinaryPredicate>
1383 pre_order_iterator one(one_), two(two_);
1385 if (!fun(*one, *two))
return false;
1390 template <
class T,
class tree_node_allocator>
1399 template <
class T,
class tree_node_allocator>
1406 template <
class T,
class tree_node_allocator>
1419 template <
class T,
class tree_node_allocator>
1426 template <
class T,
class tree_node_allocator>
1432 while (pos->parent != 0)
1440 template <
class T,
class tree_node_allocator>
1444 if (pos == 0)
return 0;
1446 unsigned int ret = 1;
1451 while ((pos = pos->next_sibling))
1456 template <
class T,
class tree_node_allocator>
1460 unsigned int ret = 0;
1461 while (pos->next_sibling &&
1462 pos->next_sibling != head &&
1463 pos->next_sibling != feet)
1466 pos = pos->next_sibling;
1471 template <
class T,
class tree_node_allocator>
1477 if (it.node->prev_sibling)
1478 it.node->prev_sibling->next_sibling = nxt;
1480 it.node->parent->first_child = nxt;
1481 nxt->prev_sibling = it.node->prev_sibling;
1484 nxtnxt->prev_sibling = it.node;
1486 it.node->parent->last_child = it.node;
1487 nxt->next_sibling = it.node;
1488 it.node->prev_sibling = nxt;
1489 it.node->next_sibling = nxtnxt;
1507 template <
class T,
class tree_node_allocator>
1515 if (tmp == it)
return true;
1521 template <
class T,
class tree_node_allocator>
1524 if (it.node == 0 || it.node == feet)
return false;
1528 template <
class T,
class tree_node_allocator>
1531 unsigned int ind = 0;
1532 if (it.node->parent == 0)
1534 while (it.node->prev_sibling != head)
1536 it.node = it.node->prev_sibling;
1542 while (it.node->prev_sibling != 0)
1544 it.node = it.node->prev_sibling;
1552 template <
class T,
class tree_node_allocator>
1559 tmp = tmp->next_sibling;
1569 template <
class T,
class tree_node_allocator>
1571 : node(0), skip_current_children_(false)
1575 template <
class T,
class tree_node_allocator>
1577 : node(tn), skip_current_children_(false)
1581 template <
class T,
class tree_node_allocator>
1587 template <
class T,
class tree_node_allocator>
1590 return &(node->data);
1593 template <
class T,
class tree_node_allocator>
1596 if (other.node != this->node)
return true;
1600 template <
class T,
class tree_node_allocator>
1603 if (other.node == this->node)
return true;
1607 template <
class T,
class tree_node_allocator>
1610 if (other.node != this->node)
return true;
1614 template <
class T,
class tree_node_allocator>
1617 if (other.node == this->node)
return true;
1621 template <
class T,
class tree_node_allocator>
1624 if (other.node != this->node)
return true;
1628 template <
class T,
class tree_node_allocator>
1631 if (other.node == this->node)
return true;
1635 template <
class T,
class tree_node_allocator>
1638 sibling_iterator ret(node->first_child);
1639 ret.parent_ = this->node;
1643 template <
class T,
class tree_node_allocator>
1646 sibling_iterator ret(0);
1651 template <
class T,
class tree_node_allocator>
1654 skip_current_children_ =
true;
1657 template <
class T,
class tree_node_allocator>
1661 if (pos == 0)
return 0;
1663 unsigned int ret = 1;
1664 while (pos != node->last_child)
1667 pos = pos->next_sibling;
1676 template <
class T,
class tree_node_allocator>
1682 template <
class T,
class tree_node_allocator>
1688 template <
class T,
class tree_node_allocator>
1690 : iterator_base(other.node)
1694 template <
class T,
class tree_node_allocator>
1696 : iterator_base(other.node)
1698 if (this->node == 0)
1700 if (other.range_last() != 0)
1701 this->node = other.range_last();
1703 this->node = other.parent_;
1709 template <
class T,
class tree_node_allocator>
1712 assert(this->node != 0);
1713 if (!this->skip_current_children_ && this->node->first_child != 0)
1715 this->node = this->node->first_child;
1719 this->skip_current_children_ =
false;
1720 while (this->node->next_sibling == 0)
1722 this->node = this->node->parent;
1723 if (this->node == 0)
1726 this->node = this->node->next_sibling;
1731 template <
class T,
class tree_node_allocator>
1734 assert(this->node != 0);
1735 if (this->node->prev_sibling)
1737 this->node = this->node->prev_sibling;
1738 while (this->node->last_child)
1739 this->node = this->node->last_child;
1743 this->node = this->node->parent;
1744 if (this->node == 0)
1750 template <
class T,
class tree_node_allocator>
1753 pre_order_iterator copy = *
this;
1758 template <
class T,
class tree_node_allocator>
1761 pre_order_iterator copy = *
this;
1766 template <
class T,
class tree_node_allocator>
1777 template <
class T,
class tree_node_allocator>
1792 template <
class T,
class tree_node_allocator>
1798 template <
class T,
class tree_node_allocator>
1804 template <
class T,
class tree_node_allocator>
1806 : iterator_base(other.node)
1810 template <
class T,
class tree_node_allocator>
1812 : iterator_base(other.node)
1814 if (this->node == 0)
1816 if (other.range_last() != 0)
1817 this->node = other.range_last();
1819 this->node = other.parent_;
1825 template <
class T,
class tree_node_allocator>
1828 assert(this->node != 0);
1829 if (this->node->next_sibling == 0)
1831 this->node = this->node->parent;
1832 this->skip_current_children_ =
false;
1836 this->node = this->node->next_sibling;
1837 if (this->skip_current_children_)
1839 this->skip_current_children_ =
false;
1843 while (this->node->first_child)
1844 this->node = this->node->first_child;
1850 template <
class T,
class tree_node_allocator>
1853 assert(this->node != 0);
1854 if (this->skip_current_children_ || this->node->last_child == 0)
1856 this->skip_current_children_ =
false;
1857 while (this->node->prev_sibling == 0)
1858 this->node = this->node->parent;
1859 this->node = this->node->prev_sibling;
1863 this->node = this->node->last_child;
1868 template <
class T,
class tree_node_allocator>
1871 post_order_iterator copy = *
this;
1876 template <
class T,
class tree_node_allocator>
1879 post_order_iterator copy = *
this;
1885 template <
class T,
class tree_node_allocator>
1896 template <
class T,
class tree_node_allocator>
1907 template <
class T,
class tree_node_allocator>
1910 assert(this->node != 0);
1911 while (this->node->first_child)
1912 this->node = this->node->first_child;
1918 template <
class T,
class tree_node_allocator>
1922 set_first_parent_();
1925 template <
class T,
class tree_node_allocator>
1929 set_first_parent_();
1932 template <
class T,
class tree_node_allocator>
1934 : iterator_base(other.node)
1936 set_first_parent_();
1939 template <
class T,
class tree_node_allocator>
1941 : iterator_base(other.node), first_parent_(other.parent_)
1943 find_leftmost_parent_();
1946 template <
class T,
class tree_node_allocator>
1948 : iterator_base(other.node), first_parent_(other.first_parent_)
1952 template <
class T,
class tree_node_allocator>
1958 if (this->node == 0)
return;
1959 if (this->node->parent != 0)
1960 first_parent_ = this->node->
parent;
1962 find_leftmost_parent_();
1965 template <
class T,
class tree_node_allocator>
1969 tree_node *tmppar = first_parent_;
1970 while (tmppar->prev_sibling)
1972 tmppar = tmppar->prev_sibling;
1973 if (tmppar->first_child)
1974 first_parent_ = tmppar;
1978 template <
class T,
class tree_node_allocator>
1981 assert(this->node != 0);
1983 if (this->node->next_sibling)
1985 this->node = this->node->next_sibling;
1989 int relative_depth = 0;
1993 this->node = this->node->parent;
1994 if (this->node == 0)
return *
this;
1997 while (this->node->next_sibling == 0);
1999 this->node = this->node->next_sibling;
2000 while (this->node->first_child == 0)
2002 if (this->node->next_sibling == 0)
2004 this->node = this->node->next_sibling;
2005 if (this->node == 0)
return *
this;
2007 while (relative_depth < 0 && this->node->first_child != 0)
2009 this->node = this->node->first_child;
2012 if (relative_depth < 0)
2014 if (this->node->next_sibling == 0)
goto upper;
2040 template <
class T,
class tree_node_allocator>
2043 assert(this->node != 0);
2044 if (this->node->prev_sibling != 0)
2046 this->node = this->node->prev_sibling;
2047 assert(this->node != 0);
2048 if (this->node->parent == 0 && this->node->prev_sibling == 0)
2053 tree_node *par = this->node->parent;
2056 par = par->prev_sibling;
2063 while (par->last_child == 0);
2064 this->node = par->last_child;
2069 template <
class T,
class tree_node_allocator>
2072 fixed_depth_iterator copy = *
this;
2077 template <
class T,
class tree_node_allocator>
2080 fixed_depth_iterator copy = *
this;
2085 template <
class T,
class tree_node_allocator>
2096 template <
class T,
class tree_node_allocator>
2112 template <
class T,
class tree_node_allocator>
2119 template <
class T,
class tree_node_allocator>
2126 template <
class T,
class tree_node_allocator>
2128 : iterator_base(other.node)
2133 template <
class T,
class tree_node_allocator>
2135 : iterator_base(other), parent_(other.parent_)
2139 template <
class T,
class tree_node_allocator>
2143 if (this->node == 0)
return;
2144 if (this->node->parent != 0)
2145 parent_ = this->node->
parent;
2148 template <
class T,
class tree_node_allocator>
2156 template <
class T,
class tree_node_allocator>
2159 if (this->node) this->node = this->node->prev_sibling;
2163 this->node = parent_->last_child;
2168 template <
class T,
class tree_node_allocator>
2171 sibling_iterator copy = *
this;
2176 template <
class T,
class tree_node_allocator>
2179 sibling_iterator copy = *
this;
2184 template <
class T,
class tree_node_allocator>
2195 template <
class T,
class tree_node_allocator>
2206 template <
class T,
class tree_node_allocator>
2209 tree_node *tmp = parent_->first_child;
2213 template <
class T,
class tree_node_allocator>
2216 return parent_->last_child;
void clear()
Erase all nodes of the tree.
iter replace(iter position, const T &x)
Replace node at 'position' with other node (keeping same children); 'position' becomes invalid...
void swap(sibling_iterator it)
Exchange the node (plus subtree) with its sibling node (do nothing if no sibling present).
unsigned int number_of_children(const iterator_base &) const
Count the number of children of node at position.
fixed_depth_iterator end_fixed(const iterator_base &, unsigned int) const
Return fixed-depth iterator to end of the nodes at given depth.
void erase_children(const iterator_base &)
Erase all children of the node pointed to by iterator.
iter reparent(iter position, sibling_iterator begin, sibling_iterator end)
Move nodes in range to be children of 'position'.
post_order_iterator begin_post() const
Return post-order iterator to the beginning of the tree.
iter erase(iter)
Erase element at position pointed to by iterator, return incremented iterator.
SGMLApplication::Position position
unsigned int number_of_children() const
Number of children of the node pointed to by the iterator.
pre_order_iterator set_head(const T &x)
Short-hand to insert topmost node in otherwise empty tree.
void skip_children()
When called, the next increment/decrement skips children of this node.
iter flatten(iter position)
Move all children of node at 'position' to be siblings, returns position.
tree subtree(sibling_iterator from, sibling_iterator to) const
Extract a new tree formed by the range of siblings plus all their children.
int depth(const iterator_base &) const
Compute the depth to the root.
iter move_before(iter target, iter source)
Move 'source' node (plus its children) to become the previous sibling of 'target'.
bool empty() const
Check if tree is empty.
Iterator which traverses only the nodes which are siblings of each other.
pre_order_iterator end() const
Return iterator to the end of the tree.
int size() const
Count the total number of nodes.
iter insert_after(iter position, const T &x)
Insert node as next sibling of node pointed to by position.
A node in the tree, combining links to other nodes as well as the actual data.
post_order_iterator end_post() const
Return post-order iterator to the end of the tree.
Base class for iterators, only pointers stored, no traversal logic.
pre_order_iterator begin() const
Return iterator to the beginning of the tree.
iter previous_sibling(iter) const
Return iterator to the previous sibling of a node.
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...
iter parent(iter) const
Return iterator to the parent of a node.
iter next_sibling(iter) const
Return iterator to the next sibling of a node.
bool equal(const iter &one, const iter &two, const iter &three) const
Compare two ranges of nodes (compares nodes as well as tree structure).
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.
void descend_all()
Set iterator to the first child as deep as possible down the tree.
bool is_valid(const iterator_base &) const
Determine whether the iterator is an 'end' iterator and thus not actually pointing to a node...
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...
Depth-first iterator, first accessing the children, then the node itself.
T value_type
Value of the data stored at a node.
unsigned int number_of_siblings(const iterator_base &) const
Count the number of 'next' siblings of node at iterator.
iter append_child(iter position)
Insert empty node as last child of node pointed to by position.
iter insert(iter position, const T &x)
Insert node as previous sibling of node pointed to by position.
unsigned int index(sibling_iterator it) const
Determine the index of a node in the range of siblings to which it belongs.
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).
Iterator which traverses only the nodes at a given depth from the root.
fixed_depth_iterator begin_fixed(const iterator_base &, unsigned int) const
Return fixed-depth iterator to the first node at a given depth.
iter move_ontop(iter target, iter source)
Move 'source' node (plus its children) to become the node at 'target' (erasing the node at 'target')...
Depth-first iterator, first accessing the node, then its children.
sibling_iterator child(const iterator_base &position, unsigned int) const
Inverse of 'index': return the n-th child of the node at position.
Comparator class for iterators (compares the actual node content, not pointer values).
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.
iter move_after(iter target, iter source)
Move 'source' node (plus its children) to become the next sibling of 'target'.
pre_order_iterator iterator
The default iterator type throughout the tree class.
iter next_at_same_depth(iter) const
Return iterator to the next node at a given depth.