56 : parent(0), first_child(0), last_child(0), prev_sibling(0), next_sibling(0)
62 : parent(0), first_child(0), last_child(0), prev_sibling(0), next_sibling(0), data(val)
66 template <
class T,
class tree_node_allocator = std::allocator<tree_node_<T> > >
75 class pre_order_iterator;
76 class post_order_iterator;
77 class sibling_iterator;
82 tree(
const iterator_base&);
89 class iterator_base :
public stlport::bidirectional_iterator<T, ptrdiff_t> {
276 template<
typename iter>
static iter
parent(iter);
287 template<
typename iter> iter
erase(iter);
292 template<
typename iter> iter
append_child(iter position);
295 template<
typename iter> iter
append_child(iter position,
const T& x);
296 template<
typename iter> iter
prepend_child(iter position,
const T& x);
298 template<
typename iter> iter
append_child(iter position, iter other_position);
299 template<
typename iter> iter
prepend_child(iter position, iter other_position);
307 template<
typename iter> iter
insert(iter position,
const T& x);
313 template<
typename iter> iter
insert_after(iter position,
const T& x);
318 template<
typename iter> iter
replace(iter position,
const T& x);
326 template<
typename iter> iter
flatten(iter position);
330 template<
typename iter> iter
reparent(iter position, iter from);
333 template<
typename iter> iter
wrap(iter position,
const T& x);
336 template<
typename iter> iter
move_after(iter target, iter source);
338 template<
typename iter> iter
move_before(iter target, iter source);
341 template<
typename iter> iter
move_ontop(iter target, iter source);
345 bool duplicate_leaves=
false);
348 template<
class StrictWeakOrdering>
351 template<
typename iter>
352 bool equal(
const iter& one,
const iter& two,
const iter& three)
const;
353 template<
typename iter,
class BinaryPredicate>
354 bool equal(
const iter& one,
const iter& two,
const iter& three, BinaryPredicate)
const;
355 template<
typename iter>
357 template<
typename iter,
class BinaryPredicate>
358 bool equal_subtree(
const iter& one,
const iter& two, BinaryPredicate)
const;
420 template<
class StrictWeakOrdering>
476 template <
class T,
class tree_node_allocator>
482 template <
class T,
class tree_node_allocator>
489 template <
class T,
class tree_node_allocator>
497 template <
class T,
class tree_node_allocator>
507 template <
class T,
class tree_node_allocator>
528 template <
class T,
class tree_node_allocator>
536 template <
class T,
class tree_node_allocator>
543 template <
class T,
class tree_node_allocator>
548 while(it!=other.
end()) {
555 while(it!=other.
end()) {
564 template <
class T,
class tree_node_allocator>
572 template<
class T,
class tree_node_allocator>
576 if(it.node==0)
return;
587 alloc_.deallocate(prev,1);
589 it.node->first_child=0;
590 it.node->last_child=0;
594 template<
class T,
class tree_node_allocator>
623 template <
class T,
class tree_node_allocator>
629 template <
class T,
class tree_node_allocator>
635 template <
class T,
class tree_node_allocator>
641 template <
class T,
class tree_node_allocator>
647 template <
class T,
class tree_node_allocator>
658 template <
class T,
class tree_node_allocator>
664 template <
class T,
class tree_node_allocator>
671 unsigned int curdepth=0;
678 throw std::range_error(
"tree: begin_fixed out of range");
681 throw std::range_error(
"tree: begin_fixed out of range");
695 template <
class T,
class tree_node_allocator>
700 unsigned int curdepth=1;
705 throw std::range_error(
"tree: end_fixed out of range");
713 template <
class T,
class tree_node_allocator>
717 if(pos.node->first_child==0) {
720 return pos.node->first_child;
723 template <
class T,
class tree_node_allocator>
731 template <
class T,
class tree_node_allocator>
742 template <
class T,
class tree_node_allocator>
748 template <
class T,
class tree_node_allocator>
757 template <
class T,
class tree_node_allocator>
763 template <
class T,
class tree_node_allocator>
764 template <
typename iter>
767 assert(position.node!=0);
768 return iter(position.node->parent);
771 template <
class T,
class tree_node_allocator>
772 template <
typename iter>
775 assert(position.node!=0);
777 ret.node=position.node->prev_sibling;
781 template <
class T,
class tree_node_allocator>
782 template <
typename iter>
785 assert(position.node!=0);
787 ret.node=position.node->next_sibling;
791 template <
class T,
class tree_node_allocator>
792 template <
typename iter>
836 template <
class T,
class tree_node_allocator>
837 template <
typename iter>
840 assert(position.node!=
head);
841 assert(position.node!=
feet);
842 assert(position.node);
850 tmp->
parent=position.node;
851 if(position.node->last_child!=0) {
852 position.node->last_child->next_sibling=tmp;
858 position.node->last_child=tmp;
863 template <
class T,
class tree_node_allocator>
864 template <
typename iter>
867 assert(position.node!=
head);
868 assert(position.node!=
feet);
869 assert(position.node);
877 tmp->
parent=position.node;
878 if(position.node->first_child!=0) {
879 position.node->first_child->prev_sibling=tmp;
885 position.node->prev_child=tmp;
890 template <
class T,
class tree_node_allocator>
891 template <
class iter>
898 assert(position.node!=
head);
899 assert(position.node!=
feet);
900 assert(position.node);
908 tmp->
parent=position.node;
909 if(position.node->last_child!=0) {
910 position.node->last_child->next_sibling=tmp;
916 position.node->last_child=tmp;
921 template <
class T,
class tree_node_allocator>
922 template <
class iter>
925 assert(position.node!=
head);
926 assert(position.node!=
feet);
927 assert(position.node);
935 tmp->
parent=position.node;
936 if(position.node->first_child!=0) {
937 position.node->first_child->prev_sibling=tmp;
943 position.node->first_child=tmp;
948 template <
class T,
class tree_node_allocator>
949 template <
class iter>
952 assert(position.node!=
head);
953 assert(position.node!=
feet);
954 assert(position.node);
960 template <
class T,
class tree_node_allocator>
961 template <
class iter>
964 assert(position.node!=
head);
965 assert(position.node!=
feet);
966 assert(position.node);
972 template <
class T,
class tree_node_allocator>
973 template <
class iter>
976 assert(position.node!=
head);
977 assert(position.node!=
feet);
978 assert(position.node);
989 template <
class T,
class tree_node_allocator>
990 template <
class iter>
993 assert(position.node!=
head);
994 assert(position.node!=
feet);
995 assert(position.node);
1006 template <
class T,
class tree_node_allocator>
1013 template <
class T,
class tree_node_allocator>
1014 template <
class iter>
1017 if(position.node==0) {
1022 alloc_.construct(tmp, x);
1027 tmp->
parent=position.node->parent;
1030 position.node->prev_sibling=tmp;
1034 tmp->
parent->first_child=tmp;
1041 template <
class T,
class tree_node_allocator>
1045 alloc_.construct(tmp, x);
1051 if(position.
node==0) {
1054 tmp->
parent->last_child=tmp;
1064 tmp->
parent->first_child=tmp;
1071 template <
class T,
class tree_node_allocator>
1072 template <
class iter>
1076 alloc_.construct(tmp, x);
1081 tmp->
parent=position.node->parent;
1084 position.node->next_sibling=tmp;
1088 tmp->
parent->last_child=tmp;
1096 template <
class T,
class tree_node_allocator>
1097 template <
class iter>
1106 template <
class T,
class tree_node_allocator>
1107 template <
class iter>
1126 template <
class T,
class tree_node_allocator>
1127 template <
class iter>
1132 position.node->data=x;
1138 template <
class T,
class tree_node_allocator>
1139 template <
class iter>
1142 assert(position.node!=
head);
1152 alloc_.construct(tmp, (*from));
1157 if(current_to->
parent!=0)
1158 current_to->
parent->first_child=tmp;
1165 if(current_to->
parent!=0)
1166 current_to->
parent->last_child=tmp;
1174 alloc_.destroy(current_to);
1175 alloc_.deallocate(current_to,1);
1179 tree_node *last=from.node->next_sibling;
1184 assert(current_from!=0);
1190 while(current_from->
next_sibling==0 && current_from!=start_from) {
1191 current_from=current_from->
parent;
1193 assert(current_from!=0);
1196 if(current_from!=last) {
1200 }
while(current_from!=last);
1205 template <
class T,
class tree_node_allocator>
1215 while((++orig_begin)!=orig_end)
1218 while((++new_begin)!=new_end)
1230 if(new_first==new_last)
1250 template <
class T,
class tree_node_allocator>
1251 template <
typename iter>
1254 if(position.node->first_child==0)
1259 tmp->
parent=position.node->parent;
1262 if(position.node->next_sibling) {
1263 position.node->last_child->next_sibling=position.node->next_sibling;
1264 position.node->next_sibling->prev_sibling=position.node->last_child;
1267 position.node->parent->last_child=position.node->last_child;
1269 position.node->next_sibling=position.node->first_child;
1270 position.node->next_sibling->prev_sibling=position.node;
1271 position.node->first_child=0;
1272 position.node->last_child=0;
1278 template <
class T,
class tree_node_allocator>
1279 template <
typename iter>
1285 assert(first!=position.node);
1287 if(begin==end)
return begin;
1289 while((++begin)!=end) {
1305 if(position.node->first_child==0) {
1306 position.node->first_child=first;
1311 position.node->last_child->next_sibling=first;
1313 position.node->last_child=last;
1319 pos->
parent=position.node;
1320 if(pos==last)
break;
1327 template <
class T,
class tree_node_allocator>
1330 if(from.node->first_child==0)
return position;
1331 return reparent(position, from.node->first_child,
end(from));
1334 template <
class T,
class tree_node_allocator>
1337 assert(position.node!=0);
1340 iter ret =
insert(position, x);
1345 template <
class T,
class tree_node_allocator>
1353 if(dst==src)
return source;
1366 else dst->
parent->last_child=src;
1374 template <
class T,
class tree_node_allocator>
1382 if(dst==src)
return source;
1395 else dst->
parent->first_child=src;
1404 template <
class T,
class tree_node_allocator>
1413 assert(dst_prev_sibling);
1418 if(dst==src)
return source;
1419 if(dst_prev_sibling)
1420 if(dst_prev_sibling==src)
1430 if(dst_prev_sibling!=0) dst_prev_sibling->
next_sibling=src;
1441 template <
class T,
class tree_node_allocator>
1449 if(dst==src)
return source;
1470 if(b_prev_sibling!=0) b_prev_sibling->
next_sibling=src;
1472 if(b_next_sibling!=0) b_next_sibling->
prev_sibling=src;
1480 template <
class T,
class tree_node_allocator>
1483 bool duplicate_leaves)
1486 while(from1!=from2) {
1487 if((fnd=std::find(to1, to2, (*from1))) != to2) {
1489 if(duplicate_leaves)
1504 template <
class T,
class tree_node_allocator>
1508 sort(from, to, comp, deep);
1511 template <
class T,
class tree_node_allocator>
1512 template <
class StrictWeakOrdering>
1514 StrictWeakOrdering comp,
bool deep)
1516 if(from==to)
return;
1520 std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> > nodes(comp);
1523 nodes.insert(it.
node);
1532 typename std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> >
::iterator nit=nodes.
begin(), eit=nodes.
end();
1534 if((*nit)->parent!=0)
1535 (*nit)->parent->first_child=(*nit);
1541 (*nit)->prev_sibling=prev;
1552 (*eit)->next_sibling=next;
1555 if((*eit)->parent!=0)
1556 (*eit)->
parent->last_child=(*eit);
1571 template <
class T,
class tree_node_allocator>
1572 template <
typename iter>
1575 std::equal_to<T> comp;
1576 return equal(one_, two, three_, comp);
1579 template <
class T,
class tree_node_allocator>
1580 template <
typename iter>
1583 std::equal_to<T> comp;
1587 template <
class T,
class tree_node_allocator>
1588 template <
typename iter,
class BinaryPredicate>
1595 while(one!=two &&
is_valid(three)) {
1596 if(!fun(*one,*three))
1606 template <
class T,
class tree_node_allocator>
1607 template <
typename iter,
class BinaryPredicate>
1612 if(!fun(*one,*two))
return false;
1617 template <
class T,
class tree_node_allocator>
1626 template <
class T,
class tree_node_allocator>
1633 template <
class T,
class tree_node_allocator>
1645 template <
class T,
class tree_node_allocator>
1650 eit.skip_children();
1659 template <
class T,
class tree_node_allocator>
1666 template <
class T,
class tree_node_allocator>
1679 template <
class T,
class tree_node_allocator>
1685 while(pos->
parent!=0 && pos!=root.node) {
1692 template <
class T,
class tree_node_allocator>
1703 template <
class T,
class tree_node_allocator>
1708 if(tmp==0 || tmp==
head || tmp==
feet)
return -1;
1710 int curdepth=0, maxdepth=0;
1713 if(tmp==pos.node)
return maxdepth;
1718 if(tmp==0)
return maxdepth;
1722 if(tmp==pos.node)
return maxdepth;
1727 maxdepth=std::max(curdepth, maxdepth);
1731 template <
class T,
class tree_node_allocator>
1735 if(pos==0)
return 0;
1747 template <
class T,
class tree_node_allocator>
1771 template <
class T,
class tree_node_allocator>
1792 template <
class T,
class tree_node_allocator>
1839 template <
class T,
class tree_node_allocator>
1846 if(tmp==it)
return true;
1852 template <
class T,
class tree_node_allocator>
1855 if(it.node==0 || it.node==
feet || it.node==
head)
return false;
1859 template <
class T,
class tree_node_allocator>
1863 std::set<iterator, iterator_base_less> parents;
1869 parents.insert(walk);
1876 if(parents.find(walk) != parents.end())
break;
1882 template <
class T,
class tree_node_allocator>
1901 template <
class T,
class tree_node_allocator>
1905 if(it.node->parent==0) {
1913 tmp=it.node->parent->first_child;
1923 template <
class T,
class tree_node_allocator>
1942 template <
class T,
class tree_node_allocator>
1958 template <
class T,
class tree_node_allocator>
1960 : node(0), skip_current_children_(false)
1964 template <
class T,
class tree_node_allocator>
1966 : node(tn), skip_current_children_(false)
1970 template <
class T,
class tree_node_allocator>
1976 template <
class T,
class tree_node_allocator>
1979 return &(node->data);
1982 template <
class T,
class tree_node_allocator>
1985 if(other.
node!=this->node)
return true;
1989 template <
class T,
class tree_node_allocator>
1992 if(other.
node==this->node)
return true;
1996 template <
class T,
class tree_node_allocator>
1999 if(other.
node!=this->node)
return true;
2003 template <
class T,
class tree_node_allocator>
2006 if(other.
node==this->node)
return true;
2010 template <
class T,
class tree_node_allocator>
2013 if(other.
node!=this->node)
return true;
2017 template <
class T,
class tree_node_allocator>
2020 if(other.
node==this->node)
return true;
2024 template <
class T,
class tree_node_allocator>
2027 if(other.
node!=this->node)
return true;
2031 template <
class T,
class tree_node_allocator>
2034 if(other.
node==this->node && other.
top_node==this->top_node)
return true;
2038 template <
class T,
class tree_node_allocator>
2041 if(node->first_child==0)
2049 template <
class T,
class tree_node_allocator>
2057 template <
class T,
class tree_node_allocator>
2060 skip_current_children_=
true;
2063 template <
class T,
class tree_node_allocator>
2066 skip_current_children_=skip;
2069 template <
class T,
class tree_node_allocator>
2073 if(pos==0)
return 0;
2087 template <
class T,
class tree_node_allocator>
2093 template <
class T,
class tree_node_allocator>
2099 template <
class T,
class tree_node_allocator>
2105 template <
class T,
class tree_node_allocator>
2119 template <
class T,
class tree_node_allocator>
2122 assert(this->node!=0);
2123 if(!this->skip_current_children_ && this->node->first_child != 0) {
2124 this->node=this->node->first_child;
2127 this->skip_current_children_=
false;
2128 while(this->node->next_sibling==0) {
2129 this->node=this->node->parent;
2133 this->node=this->node->next_sibling;
2138 template <
class T,
class tree_node_allocator>
2141 assert(this->node!=0);
2142 if(this->node->prev_sibling) {
2143 this->node=this->node->prev_sibling;
2144 while(this->node->last_child)
2145 this->node=this->node->last_child;
2148 this->node=this->node->parent;
2155 template <
class T,
class tree_node_allocator>
2163 template <
class T,
class tree_node_allocator>
2171 template <
class T,
class tree_node_allocator>
2181 template <
class T,
class tree_node_allocator>
2195 template <
class T,
class tree_node_allocator>
2201 template <
class T,
class tree_node_allocator>
2207 template <
class T,
class tree_node_allocator>
2213 template <
class T,
class tree_node_allocator>
2227 template <
class T,
class tree_node_allocator>
2230 assert(this->node!=0);
2231 if(this->node->next_sibling==0) {
2232 this->node=this->node->parent;
2233 this->skip_current_children_=
false;
2236 this->node=this->node->next_sibling;
2237 if(this->skip_current_children_) {
2238 this->skip_current_children_=
false;
2241 while(this->node->first_child)
2242 this->node=this->node->first_child;
2248 template <
class T,
class tree_node_allocator>
2251 assert(this->node!=0);
2252 if(this->skip_current_children_ || this->node->last_child==0) {
2253 this->skip_current_children_=
false;
2254 while(this->node->prev_sibling==0)
2255 this->node=this->node->parent;
2256 this->node=this->node->prev_sibling;
2259 this->node=this->node->last_child;
2264 template <
class T,
class tree_node_allocator>
2272 template <
class T,
class tree_node_allocator>
2281 template <
class T,
class tree_node_allocator>
2291 template <
class T,
class tree_node_allocator>
2301 template <
class T,
class tree_node_allocator>
2304 assert(this->node!=0);
2305 while(this->node->first_child)
2306 this->node=this->node->first_child;
2312 template <
class T,
class tree_node_allocator>
2318 template <
class T,
class tree_node_allocator>
2325 template <
class T,
class tree_node_allocator>
2332 template <
class T,
class tree_node_allocator>
2335 if(other.
node!=this->node)
return true;
2339 template <
class T,
class tree_node_allocator>
2342 if(other.
node==this->node)
return true;
2346 template <
class T,
class tree_node_allocator>
2349 assert(this->node!=0);
2353 while(sib!=this->
end()) {
2354 traversal_queue.push(sib.
node);
2357 traversal_queue.pop();
2358 if(traversal_queue.size()>0)
2359 this->node=traversal_queue.front();
2365 template <
class T,
class tree_node_allocator>
2373 template <
class T,
class tree_node_allocator>
2387 template <
class T,
class tree_node_allocator>
2393 template <
class T,
class tree_node_allocator>
2399 template <
class T,
class tree_node_allocator>
2405 template <
class T,
class tree_node_allocator>
2411 template <
class T,
class tree_node_allocator>
2417 template <
class T,
class tree_node_allocator>
2420 if(other.
node==this->node && other.
top_node==top_node)
return true;
2424 template <
class T,
class tree_node_allocator>
2427 if(other.
node!=this->node || other.
top_node!=top_node)
return true;
2431 template <
class T,
class tree_node_allocator>
2434 assert(this->node!=0);
2436 if(this->node->next_sibling) {
2437 this->node=this->node->next_sibling;
2440 int relative_depth=0;
2443 if(this->node==this->top_node) {
2447 this->node=this->node->parent;
2448 if(this->node==0)
return *
this;
2450 }
while(this->node->next_sibling==0);
2452 this->node=this->node->next_sibling;
2453 while(this->node->first_child==0) {
2454 if(this->node->next_sibling==0)
2456 this->node=this->node->next_sibling;
2457 if(this->node==0)
return *
this;
2459 while(relative_depth<0 && this->node->first_child!=0) {
2460 this->node=this->node->first_child;
2463 if(relative_depth<0) {
2464 if(this->node->next_sibling==0)
goto upper;
2471 template <
class T,
class tree_node_allocator>
2474 assert(this->node!=0);
2476 if(this->node->prev_sibling) {
2477 this->node=this->node->prev_sibling;
2480 int relative_depth=0;
2483 if(this->node==this->top_node) {
2487 this->node=this->node->parent;
2488 if(this->node==0)
return *
this;
2490 }
while(this->node->prev_sibling==0);
2492 this->node=this->node->prev_sibling;
2493 while(this->node->last_child==0) {
2494 if(this->node->prev_sibling==0)
2496 this->node=this->node->prev_sibling;
2497 if(this->node==0)
return *
this;
2499 while(relative_depth<0 && this->node->last_child!=0) {
2500 this->node=this->node->last_child;
2503 if(relative_depth<0) {
2504 if(this->node->prev_sibling==0)
goto upper;
2533 template <
class T,
class tree_node_allocator>
2541 template <
class T,
class tree_node_allocator>
2549 template <
class T,
class tree_node_allocator>
2559 template <
class T,
class tree_node_allocator>
2572 template <
class T,
class tree_node_allocator>
2579 template <
class T,
class tree_node_allocator>
2586 template <
class T,
class tree_node_allocator>
2593 template <
class T,
class tree_node_allocator>
2599 template <
class T,
class tree_node_allocator>
2603 if(this->node==0)
return;
2604 if(this->node->parent!=0)
2605 parent_=this->node->parent;
2608 template <
class T,
class tree_node_allocator>
2612 this->node=this->node->next_sibling;
2616 template <
class T,
class tree_node_allocator>
2619 if(this->node) this->node=this->node->prev_sibling;
2622 this->node=parent_->last_child;
2627 template <
class T,
class tree_node_allocator>
2635 template <
class T,
class tree_node_allocator>
2643 template <
class T,
class tree_node_allocator>
2653 template <
class T,
class tree_node_allocator>
2663 template <
class T,
class tree_node_allocator>
2670 template <
class T,
class tree_node_allocator>
2678 template <
class T,
class tree_node_allocator>
2684 template <
class T,
class tree_node_allocator>
2690 template <
class T,
class tree_node_allocator>
2696 template <
class T,
class tree_node_allocator>
2709 template <
class T,
class tree_node_allocator>
2712 assert(this->node!=0);
2713 if(this->node->first_child!=0) {
2714 while(this->node->first_child)
2715 this->node=this->node->first_child;
2718 while(this->node->next_sibling==0) {
2719 if (this->node->parent==0)
return *
this;
2720 this->node=this->node->parent;
2721 if (top_node != 0 && this->node==top_node)
return *
this;
2723 this->node=this->node->next_sibling;
2724 while(this->node->first_child)
2725 this->node=this->node->first_child;
2730 template <
class T,
class tree_node_allocator>
2733 assert(this->node!=0);
2734 while (this->node->prev_sibling==0) {
2735 if (this->node->parent==0)
return *
this;
2736 this->node=this->node->parent;
2737 if (top_node !=0 && this->node==top_node)
return *
this;
2739 this->node=this->node->prev_sibling;
2740 while(this->node->last_child)
2741 this->node=this->node->last_child;
2745 template <
class T,
class tree_node_allocator>
2753 template <
class T,
class tree_node_allocator>
2762 template <
class T,
class tree_node_allocator>
2772 template <
class T,
class tree_node_allocator>